﻿using System;
using System.ComponentModel;
using System.Runtime.InteropServices;

namespace HalconDotNet
{
	/// <summary>Represents an instance of a HALCON window.</summary>
	// Token: 0x02000071 RID: 113
	public class HWindow : HHandle
	{
		// Token: 0x06001AC6 RID: 6854 RVA: 0x0000883B File Offset: 0x00006A3B
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HWindow() : base(HHandleBase.UNDEF)
		{
		}

		// Token: 0x06001AC7 RID: 6855 RVA: 0x000A5802 File Offset: 0x000A3A02
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HWindow(IntPtr handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x06001AC8 RID: 6856 RVA: 0x000A5811 File Offset: 0x000A3A11
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HWindow(HHandle handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x06001AC9 RID: 6857 RVA: 0x000A5820 File Offset: 0x000A3A20
		private void AssertSemType()
		{
			base.AssertSemType("window");
		}

		// Token: 0x06001ACA RID: 6858 RVA: 0x000A582D File Offset: 0x000A3A2D
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HWindow obj)
		{
			obj = new HWindow(HHandleBase.UNDEF);
			return obj.Load(proc, parIndex, err);
		}

		// Token: 0x06001ACB RID: 6859 RVA: 0x000A5848 File Offset: 0x000A3A48
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HWindow[] obj)
		{
			HTuple htuple;
			err = HTuple.LoadNew(proc, parIndex, err, out htuple);
			obj = new HWindow[htuple.Length];
			for (int i = 0; i < htuple.Length; i++)
			{
				obj[i] = new HWindow(HalconAPI.IsLegacyHandleMode() ? htuple[i].IP : htuple[i].H);
			}
			htuple.Dispose();
			return err;
		}

		/// <summary>
		///   Open a graphics window.
		///   Modified instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row index of upper left corner. Default: 0</param>
		/// <param name="column">Column index of upper left corner. Default: 0</param>
		/// <param name="width">Width of the window. Default: 256</param>
		/// <param name="height">Height of the window. Default: 256</param>
		/// <param name="fatherWindow">Logical number of the father window. To specify the display as father you may enter 'root' or 0. Default: 0</param>
		/// <param name="mode">Window mode. Default: "visible"</param>
		/// <param name="machine">Name of the computer on which you want to open the window. Otherwise the empty string. Default: ""</param>
		// Token: 0x06001ACC RID: 6860 RVA: 0x000A58B8 File Offset: 0x000A3AB8
		public HWindow(int row, int column, int width, int height, HTuple fatherWindow, string mode, string machine)
		{
			IntPtr proc = HalconAPI.PreCall(1178);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.Store(proc, 4, fatherWindow);
			HalconAPI.StoreS(proc, 5, mode);
			HalconAPI.StoreS(proc, 6, machine);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(fatherWindow);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Open a graphics window.
		///   Modified instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row index of upper left corner. Default: 0</param>
		/// <param name="column">Column index of upper left corner. Default: 0</param>
		/// <param name="width">Width of the window. Default: 256</param>
		/// <param name="height">Height of the window. Default: 256</param>
		/// <param name="fatherWindow">Logical number of the father window. To specify the display as father you may enter 'root' or 0. Default: 0</param>
		/// <param name="mode">Window mode. Default: "visible"</param>
		/// <param name="machine">Name of the computer on which you want to open the window. Otherwise the empty string. Default: ""</param>
		// Token: 0x06001ACD RID: 6861 RVA: 0x000A5940 File Offset: 0x000A3B40
		public HWindow(int row, int column, int width, int height, IntPtr fatherWindow, string mode, string machine)
		{
			IntPtr proc = HalconAPI.PreCall(1178);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.StoreIP(proc, 4, fatherWindow);
			HalconAPI.StoreS(proc, 5, mode);
			HalconAPI.StoreS(proc, 6, machine);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		// Token: 0x06001ACE RID: 6862
		[DllImport("X11", EntryPoint = "XInitThreads")]
		private static extern int _XInitThreads();

		// Token: 0x06001ACF RID: 6863 RVA: 0x000A59C0 File Offset: 0x000A3BC0
		public static int XInitThreads()
		{
			int result;
			try
			{
				result = HWindow._XInitThreads();
			}
			catch (DllNotFoundException)
			{
				result = 0;
			}
			return result;
		}

		// Token: 0x06001AD0 RID: 6864 RVA: 0x000A59EC File Offset: 0x000A3BEC
		internal void OnContentUpdate(HWindow.ContentUpdateCallback f)
		{
			this._callback = f;
			this.SetContentUpdateCallback(Marshal.GetFunctionPointerForDelegate(this._callback), new IntPtr(0));
		}

		/// <summary>
		///   Display an XLD object.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="XLDObject">XLD object to display.</param>
		// Token: 0x06001AD1 RID: 6865 RVA: 0x000A5A0C File Offset: 0x000A3C0C
		public void DispXld(HXLD XLDObject)
		{
			IntPtr proc = HalconAPI.PreCall(74);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, XLDObject);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(XLDObject);
		}

		/// <summary>
		///   Gets a copy of the background image of the HALCON window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Copy of the background image.</returns>
		// Token: 0x06001AD2 RID: 6866 RVA: 0x000A5A4C File Offset: 0x000A3C4C
		public HImage GetWindowBackgroundImage()
		{
			IntPtr proc = HalconAPI.PreCall(1161);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Detach the background image from a HALCON window.
		///   Instance represents: Window handle.
		/// </summary>
		// Token: 0x06001AD3 RID: 6867 RVA: 0x000A5A94 File Offset: 0x000A3C94
		public void DetachBackgroundFromWindow()
		{
			IntPtr proc = HalconAPI.PreCall(1163);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Attach a background image to a HALCON window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="image">Background image.</param>
		// Token: 0x06001AD4 RID: 6868 RVA: 0x000A5AC8 File Offset: 0x000A3CC8
		public void AttachBackgroundToWindow(HImage image)
		{
			IntPtr proc = HalconAPI.PreCall(1164);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Detach an existing drawing object from a HALCON window.
		///   Instance represents: Window Handle.
		/// </summary>
		/// <param name="drawHandle">Handle of the drawing object.</param>
		// Token: 0x06001AD5 RID: 6869 RVA: 0x000A5B0C File Offset: 0x000A3D0C
		public void DetachDrawingObjectFromWindow(HDrawingObject drawHandle)
		{
			IntPtr proc = HalconAPI.PreCall(1165);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, drawHandle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(drawHandle);
		}

		/// <summary>
		///   Attach an existing drawing object to a HALCON window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="drawHandle">Handle of the drawing object.</param>
		// Token: 0x06001AD6 RID: 6870 RVA: 0x000A5B50 File Offset: 0x000A3D50
		public void AttachDrawingObjectToWindow(HDrawingObject drawHandle)
		{
			IntPtr proc = HalconAPI.PreCall(1166);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, drawHandle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(drawHandle);
		}

		/// <summary>
		///   Modify the pose of a 3D plot.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="lastRow">Row coordinate of the first point.</param>
		/// <param name="lastCol">Column coordinate of the first point.</param>
		/// <param name="currentRow">Row coordinate of the second point.</param>
		/// <param name="currentCol">Column coordinate of the second point.</param>
		/// <param name="mode">Navigation mode. Default: "rotate"</param>
		// Token: 0x06001AD7 RID: 6871 RVA: 0x000A5B94 File Offset: 0x000A3D94
		public void UpdateWindowPose(HTuple lastRow, HTuple lastCol, HTuple currentRow, HTuple currentCol, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(1167);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, lastRow);
			HalconAPI.Store(proc, 2, lastCol);
			HalconAPI.Store(proc, 3, currentRow);
			HalconAPI.Store(proc, 4, currentCol);
			HalconAPI.StoreS(proc, 5, mode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(lastRow);
			HalconAPI.UnpinTuple(lastCol);
			HalconAPI.UnpinTuple(currentRow);
			HalconAPI.UnpinTuple(currentCol);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Modify the pose of a 3D plot.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="lastRow">Row coordinate of the first point.</param>
		/// <param name="lastCol">Column coordinate of the first point.</param>
		/// <param name="currentRow">Row coordinate of the second point.</param>
		/// <param name="currentCol">Column coordinate of the second point.</param>
		/// <param name="mode">Navigation mode. Default: "rotate"</param>
		// Token: 0x06001AD8 RID: 6872 RVA: 0x000A5C0C File Offset: 0x000A3E0C
		public void UpdateWindowPose(double lastRow, double lastCol, double currentRow, double currentCol, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(1167);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, lastRow);
			HalconAPI.StoreD(proc, 2, lastCol);
			HalconAPI.StoreD(proc, 3, currentRow);
			HalconAPI.StoreD(proc, 4, currentCol);
			HalconAPI.StoreS(proc, 5, mode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Calculates image coordinates for a point in a 3D plot window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="image">Displayed image.</param>
		/// <param name="row">Row coordinate in the window.</param>
		/// <param name="column">Column coordinate in the window.</param>
		/// <param name="imageRow">Row coordinate in the image.</param>
		/// <param name="imageColumn">Column coordinate in the image.</param>
		/// <param name="height">Height value.</param>
		// Token: 0x06001AD9 RID: 6873 RVA: 0x000A5C6C File Offset: 0x000A3E6C
		public void UnprojectCoordinates(HImage image, HTuple row, HTuple column, out int imageRow, out int imageColumn, out HTuple height)
		{
			IntPtr proc = HalconAPI.PreCall(1168);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			num = HalconAPI.LoadI(proc, 0, num, out imageRow);
			num = HalconAPI.LoadI(proc, 1, num, out imageColumn);
			num = HTuple.LoadNew(proc, 2, num, out height);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Calculates image coordinates for a point in a 3D plot window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="image">Displayed image.</param>
		/// <param name="row">Row coordinate in the window.</param>
		/// <param name="column">Column coordinate in the window.</param>
		/// <param name="imageRow">Row coordinate in the image.</param>
		/// <param name="imageColumn">Column coordinate in the image.</param>
		/// <param name="height">Height value.</param>
		// Token: 0x06001ADA RID: 6874 RVA: 0x000A5D04 File Offset: 0x000A3F04
		public void UnprojectCoordinates(HImage image, double row, double column, out int imageRow, out int imageColumn, out int height)
		{
			IntPtr proc = HalconAPI.PreCall(1168);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreD(proc, 1, row);
			HalconAPI.StoreD(proc, 2, column);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out imageRow);
			num = HalconAPI.LoadI(proc, 1, num, out imageColumn);
			num = HalconAPI.LoadI(proc, 2, num, out height);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Get the operating system window handle.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="OSDisplayHandle">Operating system display handle (under Unix-like systems only).</param>
		/// <returns>Operating system window handle.</returns>
		// Token: 0x06001ADB RID: 6875 RVA: 0x000A5D90 File Offset: 0x000A3F90
		public IntPtr GetOsWindowHandle(out IntPtr OSDisplayHandle)
		{
			IntPtr proc = HalconAPI.PreCall(1169);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			IntPtr result;
			num = HalconAPI.LoadIP(proc, 0, num, out result);
			num = HalconAPI.LoadIP(proc, 1, num, out OSDisplayHandle);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Set the device context of a virtual graphics window (Windows NT).
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="WINHDC">device context of WINHWnd.</param>
		// Token: 0x06001ADC RID: 6876 RVA: 0x000A5DEC File Offset: 0x000A3FEC
		public void SetWindowDc(IntPtr WINHDC)
		{
			IntPtr proc = HalconAPI.PreCall(1170);
			base.Store(proc, 0);
			HalconAPI.StoreIP(proc, 1, WINHDC);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a virtual graphics window under Windows.
		///   Modified instance represents: Window handle.
		/// </summary>
		/// <param name="WINHWnd">Windows window handle of a previously created window.</param>
		/// <param name="row">Row coordinate of upper left corner. Default: 0</param>
		/// <param name="column">Column coordinate of upper left corner. Default: 0</param>
		/// <param name="width">Width of the window. Default: 512</param>
		/// <param name="height">Height of the window. Default: 512</param>
		// Token: 0x06001ADD RID: 6877 RVA: 0x000A5E28 File Offset: 0x000A4028
		public void NewExternWindow(IntPtr WINHWnd, int row, int column, int width, int height)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1171);
			HalconAPI.StoreIP(proc, 0, WINHWnd);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.StoreI(proc, 3, width);
			HalconAPI.StoreI(proc, 4, height);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Interactive output from two window buffers.
		///   Instance represents: Source window handle of the "`upper window"'.
		/// </summary>
		/// <param name="windowHandleSource2">Source window handle of the "`lower window"'.</param>
		/// <param name="windowHandle">Output window handle.</param>
		// Token: 0x06001ADE RID: 6878 RVA: 0x000A5E98 File Offset: 0x000A4098
		public void SlideImage(HWindow windowHandleSource2, HWindow windowHandle)
		{
			IntPtr proc = HalconAPI.PreCall(1172);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, windowHandleSource2);
			HalconAPI.Store(proc, 2, windowHandle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandleSource2);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Modify position and size of a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row index of upper left corner in target position. Default: 0</param>
		/// <param name="column">Column index of upper left corner in target position. Default: 0</param>
		/// <param name="width">Width of the window. Default: 512</param>
		/// <param name="height">Height of the window. Default: 512</param>
		// Token: 0x06001ADF RID: 6879 RVA: 0x000A5EE8 File Offset: 0x000A40E8
		public void SetWindowExtents(int row, int column, int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(1174);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.StoreI(proc, 3, width);
			HalconAPI.StoreI(proc, 4, height);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Open a graphics window.
		///   Modified instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row index of upper left corner. Default: 0</param>
		/// <param name="column">Column index of upper left corner. Default: 0</param>
		/// <param name="width">Width of the window. Default: 256</param>
		/// <param name="height">Height of the window. Default: 256</param>
		/// <param name="fatherWindow">Logical number of the father window. To specify the display as father you may enter 'root' or 0. Default: 0</param>
		/// <param name="mode">Window mode. Default: "visible"</param>
		/// <param name="machine">Name of the computer on which you want to open the window. Otherwise the empty string. Default: ""</param>
		// Token: 0x06001AE0 RID: 6880 RVA: 0x000A5F40 File Offset: 0x000A4140
		public void OpenWindow(int row, int column, int width, int height, HTuple fatherWindow, string mode, string machine)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1178);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.Store(proc, 4, fatherWindow);
			HalconAPI.StoreS(proc, 5, mode);
			HalconAPI.StoreS(proc, 6, machine);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(fatherWindow);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Open a graphics window.
		///   Modified instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row index of upper left corner. Default: 0</param>
		/// <param name="column">Column index of upper left corner. Default: 0</param>
		/// <param name="width">Width of the window. Default: 256</param>
		/// <param name="height">Height of the window. Default: 256</param>
		/// <param name="fatherWindow">Logical number of the father window. To specify the display as father you may enter 'root' or 0. Default: 0</param>
		/// <param name="mode">Window mode. Default: "visible"</param>
		/// <param name="machine">Name of the computer on which you want to open the window. Otherwise the empty string. Default: ""</param>
		// Token: 0x06001AE1 RID: 6881 RVA: 0x000A5FC8 File Offset: 0x000A41C8
		public void OpenWindow(int row, int column, int width, int height, IntPtr fatherWindow, string mode, string machine)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1178);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.StoreIP(proc, 4, fatherWindow);
			HalconAPI.StoreS(proc, 5, mode);
			HalconAPI.StoreS(proc, 6, machine);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Open a textual window.
		///   Modified instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row index of upper left corner. Default: 0</param>
		/// <param name="column">Column index of upper left corner. Default: 0</param>
		/// <param name="width">Window's width. Default: 256</param>
		/// <param name="height">Window's height. Default: 256</param>
		/// <param name="borderWidth">Window border's width. Default: 2</param>
		/// <param name="borderColor">Window border's color. Default: "white"</param>
		/// <param name="backgroundColor">Background color. Default: "black"</param>
		/// <param name="fatherWindow">Logical number of the father window. For the display as father you may specify 'root' or 0. Default: 0</param>
		/// <param name="mode">Window mode. Default: "visible"</param>
		/// <param name="machine">Computer name, where the window has to be opened or empty string. Default: ""</param>
		// Token: 0x06001AE2 RID: 6882 RVA: 0x000A6048 File Offset: 0x000A4248
		public void OpenTextwindow(int row, int column, int width, int height, int borderWidth, string borderColor, string backgroundColor, HTuple fatherWindow, string mode, string machine)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1179);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.StoreI(proc, 4, borderWidth);
			HalconAPI.StoreS(proc, 5, borderColor);
			HalconAPI.StoreS(proc, 6, backgroundColor);
			HalconAPI.Store(proc, 7, fatherWindow);
			HalconAPI.StoreS(proc, 8, mode);
			HalconAPI.StoreS(proc, 9, machine);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(fatherWindow);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Open a textual window.
		///   Modified instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row index of upper left corner. Default: 0</param>
		/// <param name="column">Column index of upper left corner. Default: 0</param>
		/// <param name="width">Window's width. Default: 256</param>
		/// <param name="height">Window's height. Default: 256</param>
		/// <param name="borderWidth">Window border's width. Default: 2</param>
		/// <param name="borderColor">Window border's color. Default: "white"</param>
		/// <param name="backgroundColor">Background color. Default: "black"</param>
		/// <param name="fatherWindow">Logical number of the father window. For the display as father you may specify 'root' or 0. Default: 0</param>
		/// <param name="mode">Window mode. Default: "visible"</param>
		/// <param name="machine">Computer name, where the window has to be opened or empty string. Default: ""</param>
		// Token: 0x06001AE3 RID: 6883 RVA: 0x000A60EC File Offset: 0x000A42EC
		public void OpenTextwindow(int row, int column, int width, int height, int borderWidth, string borderColor, string backgroundColor, IntPtr fatherWindow, string mode, string machine)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1179);
			HalconAPI.StoreI(proc, 0, row);
			HalconAPI.StoreI(proc, 1, column);
			HalconAPI.StoreI(proc, 2, width);
			HalconAPI.StoreI(proc, 3, height);
			HalconAPI.StoreI(proc, 4, borderWidth);
			HalconAPI.StoreS(proc, 5, borderColor);
			HalconAPI.StoreS(proc, 6, backgroundColor);
			HalconAPI.StoreIP(proc, 7, fatherWindow);
			HalconAPI.StoreS(proc, 8, mode);
			HalconAPI.StoreS(proc, 9, machine);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Copy inside an output window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1">Row index of upper left corner of the source rectangle. Default: 0</param>
		/// <param name="column1">Column index of upper left corner of the source rectangle. Default: 0</param>
		/// <param name="row2">Row index of lower right corner of the source rectangle. Default: 64</param>
		/// <param name="column2">Column index of lower right corner of the source rectangle. Default: 64</param>
		/// <param name="destRow">Row index of upper left corner of the target position. Default: 64</param>
		/// <param name="destColumn">Column index of upper left corner of the target position. Default: 64</param>
		// Token: 0x06001AE4 RID: 6884 RVA: 0x000A6188 File Offset: 0x000A4388
		public void MoveRectangle(HTuple row1, HTuple column1, HTuple row2, HTuple column2, HTuple destRow, HTuple destColumn)
		{
			IntPtr proc = HalconAPI.PreCall(1180);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row1);
			HalconAPI.Store(proc, 2, column1);
			HalconAPI.Store(proc, 3, row2);
			HalconAPI.Store(proc, 4, column2);
			HalconAPI.Store(proc, 5, destRow);
			HalconAPI.Store(proc, 6, destColumn);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			HalconAPI.UnpinTuple(destRow);
			HalconAPI.UnpinTuple(destColumn);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Copy inside an output window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1">Row index of upper left corner of the source rectangle. Default: 0</param>
		/// <param name="column1">Column index of upper left corner of the source rectangle. Default: 0</param>
		/// <param name="row2">Row index of lower right corner of the source rectangle. Default: 64</param>
		/// <param name="column2">Column index of lower right corner of the source rectangle. Default: 64</param>
		/// <param name="destRow">Row index of upper left corner of the target position. Default: 64</param>
		/// <param name="destColumn">Column index of upper left corner of the target position. Default: 64</param>
		// Token: 0x06001AE5 RID: 6885 RVA: 0x000A6218 File Offset: 0x000A4418
		public void MoveRectangle(int row1, int column1, int row2, int column2, int destRow, int destColumn)
		{
			IntPtr proc = HalconAPI.PreCall(1180);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, row1);
			HalconAPI.StoreI(proc, 2, column1);
			HalconAPI.StoreI(proc, 3, row2);
			HalconAPI.StoreI(proc, 4, column2);
			HalconAPI.StoreI(proc, 5, destRow);
			HalconAPI.StoreI(proc, 6, destColumn);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Get the window type.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Window type</returns>
		// Token: 0x06001AE6 RID: 6886 RVA: 0x000A6280 File Offset: 0x000A4480
		public string GetWindowType()
		{
			IntPtr proc = HalconAPI.PreCall(1181);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Access to a window's pixel data.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="imageRed">Pointer on red channel of pixel data.</param>
		/// <param name="imageGreen">Pointer on green channel of pixel data.</param>
		/// <param name="imageBlue">Pointer on blue channel of pixel data.</param>
		/// <param name="width">Length of an image line.</param>
		/// <param name="height">Number of image lines.</param>
		// Token: 0x06001AE7 RID: 6887 RVA: 0x000A62C8 File Offset: 0x000A44C8
		public void GetWindowPointer3(out int imageRed, out int imageGreen, out int imageBlue, out int width, out int height)
		{
			IntPtr proc = HalconAPI.PreCall(1182);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out imageRed);
			num = HalconAPI.LoadI(proc, 1, num, out imageGreen);
			num = HalconAPI.LoadI(proc, 2, num, out imageBlue);
			num = HalconAPI.LoadI(proc, 3, num, out width);
			num = HalconAPI.LoadI(proc, 4, num, out height);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Information about a window's size and position.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row index of upper left corner of the window.</param>
		/// <param name="column">Column index of upper left corner of the window.</param>
		/// <param name="width">Window width.</param>
		/// <param name="height">Window height.</param>
		// Token: 0x06001AE8 RID: 6888 RVA: 0x000A6358 File Offset: 0x000A4558
		public void GetWindowExtents(out int row, out int column, out int width, out int height)
		{
			IntPtr proc = HalconAPI.PreCall(1183);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out row);
			num = HalconAPI.LoadI(proc, 1, num, out column);
			num = HalconAPI.LoadI(proc, 2, num, out width);
			num = HalconAPI.LoadI(proc, 3, num, out height);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Write the window content in an image object.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Saved image.</returns>
		// Token: 0x06001AE9 RID: 6889 RVA: 0x000A63D8 File Offset: 0x000A45D8
		public HImage DumpWindowImage()
		{
			IntPtr proc = HalconAPI.PreCall(1184);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Write the window content to a file.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="device">Name of the target device or of the graphic format. Default: "postscript"</param>
		/// <param name="fileName">File name (without extension). Default: "halcon_dump"</param>
		// Token: 0x06001AEA RID: 6890 RVA: 0x000A6420 File Offset: 0x000A4620
		public void DumpWindow(HTuple device, string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(1185);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, device);
			HalconAPI.StoreS(proc, 2, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(device);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Write the window content to a file.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="device">Name of the target device or of the graphic format. Default: "postscript"</param>
		/// <param name="fileName">File name (without extension). Default: "halcon_dump"</param>
		// Token: 0x06001AEB RID: 6891 RVA: 0x000A646C File Offset: 0x000A466C
		public void DumpWindow(string device, string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(1185);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, device);
			HalconAPI.StoreS(proc, 2, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Copy all pixels within rectangles between output windows.
		///   Instance represents: Source window handle.
		/// </summary>
		/// <param name="windowHandleDestination">Destination window handle.</param>
		/// <param name="row1">Row index of upper left corner in the source window. Default: 0</param>
		/// <param name="column1">Column index of upper left corner in the source window. Default: 0</param>
		/// <param name="row2">Row index of lower right corner in the source window. Default: 128</param>
		/// <param name="column2">Column index of lower right corner in the source window. Default: 128</param>
		/// <param name="destRow">Row index of upper left corner in the target window. Default: 0</param>
		/// <param name="destColumn">Column index of upper left corner in the target window. Default: 0</param>
		// Token: 0x06001AEC RID: 6892 RVA: 0x000A64B0 File Offset: 0x000A46B0
		public void CopyRectangle(HWindow windowHandleDestination, HTuple row1, HTuple column1, HTuple row2, HTuple column2, HTuple destRow, HTuple destColumn)
		{
			IntPtr proc = HalconAPI.PreCall(1186);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, windowHandleDestination);
			HalconAPI.Store(proc, 2, row1);
			HalconAPI.Store(proc, 3, column1);
			HalconAPI.Store(proc, 4, row2);
			HalconAPI.Store(proc, 5, column2);
			HalconAPI.Store(proc, 6, destRow);
			HalconAPI.Store(proc, 7, destColumn);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			HalconAPI.UnpinTuple(destRow);
			HalconAPI.UnpinTuple(destColumn);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandleDestination);
		}

		/// <summary>
		///   Copy all pixels within rectangles between output windows.
		///   Instance represents: Source window handle.
		/// </summary>
		/// <param name="windowHandleDestination">Destination window handle.</param>
		/// <param name="row1">Row index of upper left corner in the source window. Default: 0</param>
		/// <param name="column1">Column index of upper left corner in the source window. Default: 0</param>
		/// <param name="row2">Row index of lower right corner in the source window. Default: 128</param>
		/// <param name="column2">Column index of lower right corner in the source window. Default: 128</param>
		/// <param name="destRow">Row index of upper left corner in the target window. Default: 0</param>
		/// <param name="destColumn">Column index of upper left corner in the target window. Default: 0</param>
		// Token: 0x06001AED RID: 6893 RVA: 0x000A6550 File Offset: 0x000A4750
		public void CopyRectangle(HWindow windowHandleDestination, int row1, int column1, int row2, int column2, int destRow, int destColumn)
		{
			IntPtr proc = HalconAPI.PreCall(1186);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, windowHandleDestination);
			HalconAPI.StoreI(proc, 2, row1);
			HalconAPI.StoreI(proc, 3, column1);
			HalconAPI.StoreI(proc, 4, row2);
			HalconAPI.StoreI(proc, 5, column2);
			HalconAPI.StoreI(proc, 6, destRow);
			HalconAPI.StoreI(proc, 7, destColumn);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandleDestination);
		}

		/// <summary>Close an output window.</summary>
		/// <param name="windowHandle">Window handle.</param>
		// Token: 0x06001AEE RID: 6894 RVA: 0x000A65C8 File Offset: 0x000A47C8
		public static void CloseWindow(HWindow[] windowHandle)
		{
			HTuple htuple = HHandleBase.ConcatArray(windowHandle);
			IntPtr proc = HalconAPI.PreCall(1187);
			HalconAPI.Store(proc, 0, htuple);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Close an output window.
		///   Instance represents: Window handle.
		/// </summary>
		// Token: 0x06001AEF RID: 6895 RVA: 0x000A660C File Offset: 0x000A480C
		public void CloseWindow()
		{
			IntPtr proc = HalconAPI.PreCall(1187);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Delete the contents of an output window.
		///   Instance represents: Window handle.
		/// </summary>
		// Token: 0x06001AF0 RID: 6896 RVA: 0x000A6640 File Offset: 0x000A4840
		public void ClearWindow()
		{
			IntPtr proc = HalconAPI.PreCall(1188);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Delete a rectangle on the output window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1">Line index of upper left corner. Default: 10</param>
		/// <param name="column1">Column index of upper left corner. Default: 10</param>
		/// <param name="row2">Row index of lower right corner. Default: 118</param>
		/// <param name="column2">Column index of lower right corner. Default: 118</param>
		// Token: 0x06001AF1 RID: 6897 RVA: 0x000A6674 File Offset: 0x000A4874
		public void ClearRectangle(HTuple row1, HTuple column1, HTuple row2, HTuple column2)
		{
			IntPtr proc = HalconAPI.PreCall(1189);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row1);
			HalconAPI.Store(proc, 2, column1);
			HalconAPI.Store(proc, 3, row2);
			HalconAPI.Store(proc, 4, column2);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Delete a rectangle on the output window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1">Line index of upper left corner. Default: 10</param>
		/// <param name="column1">Column index of upper left corner. Default: 10</param>
		/// <param name="row2">Row index of lower right corner. Default: 118</param>
		/// <param name="column2">Column index of lower right corner. Default: 118</param>
		// Token: 0x06001AF2 RID: 6898 RVA: 0x000A66E4 File Offset: 0x000A48E4
		public void ClearRectangle(int row1, int column1, int row2, int column2)
		{
			IntPtr proc = HalconAPI.PreCall(1189);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, row1);
			HalconAPI.StoreI(proc, 2, column1);
			HalconAPI.StoreI(proc, 3, row2);
			HalconAPI.StoreI(proc, 4, column2);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Print text in a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="stringVal">Tuple of output values (all types). Default: "hello"</param>
		// Token: 0x06001AF3 RID: 6899 RVA: 0x000A673C File Offset: 0x000A493C
		public void WriteString(HTuple stringVal)
		{
			IntPtr proc = HalconAPI.PreCall(1190);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, stringVal);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(stringVal);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Print text in a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="stringVal">Tuple of output values (all types). Default: "hello"</param>
		// Token: 0x06001AF4 RID: 6900 RVA: 0x000A6780 File Offset: 0x000A4980
		public void WriteString(string stringVal)
		{
			IntPtr proc = HalconAPI.PreCall(1190);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, stringVal);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set the shape of the text cursor.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="textCursor">Name of cursor shape. Default: "invisible"</param>
		// Token: 0x06001AF5 RID: 6901 RVA: 0x000A67BC File Offset: 0x000A49BC
		public void SetTshape(string textCursor)
		{
			IntPtr proc = HalconAPI.PreCall(1191);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, textCursor);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set the position of the text cursor.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row index of text cursor position. Default: 24</param>
		/// <param name="column">Column index of text cursor position. Default: 12</param>
		// Token: 0x06001AF6 RID: 6902 RVA: 0x000A67F8 File Offset: 0x000A49F8
		public void SetTposition(int row, int column)
		{
			IntPtr proc = HalconAPI.PreCall(1192);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Read a string in a text window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="inString">Default string (visible before input). Default: ""</param>
		/// <param name="length">Maximum number of characters. Default: 32</param>
		/// <returns>Read string.</returns>
		// Token: 0x06001AF7 RID: 6903 RVA: 0x000A683C File Offset: 0x000A4A3C
		public string ReadString(string inString, int length)
		{
			IntPtr proc = HalconAPI.PreCall(1193);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, inString);
			HalconAPI.StoreI(proc, 2, length);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Read a character from a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="code">Code for input character.</param>
		/// <returns>Input character (if it is not a control character).</returns>
		// Token: 0x06001AF8 RID: 6904 RVA: 0x000A6894 File Offset: 0x000A4A94
		public string ReadChar(out string code)
		{
			IntPtr proc = HalconAPI.PreCall(1194);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			num = HalconAPI.LoadS(proc, 1, num, out code);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Set the position of the text cursor to the beginning of the next line.
		///   Instance represents: Window handle.
		/// </summary>
		// Token: 0x06001AF9 RID: 6905 RVA: 0x000A68F0 File Offset: 0x000A4AF0
		public void NewLine()
		{
			IntPtr proc = HalconAPI.PreCall(1195);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Get the shape of the text cursor.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Name of the current text cursor.</returns>
		// Token: 0x06001AFA RID: 6906 RVA: 0x000A6924 File Offset: 0x000A4B24
		public string GetTshape()
		{
			IntPtr proc = HalconAPI.PreCall(1196);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get cursor position.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row index of text cursor position.</param>
		/// <param name="column">Column index of text cursor position.</param>
		// Token: 0x06001AFB RID: 6907 RVA: 0x000A696C File Offset: 0x000A4B6C
		public void GetTposition(out int row, out int column)
		{
			IntPtr proc = HalconAPI.PreCall(1197);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out row);
			num = HalconAPI.LoadI(proc, 1, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Get the maximum size of all characters of a font.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="maxDescent">Maximum extension below baseline.</param>
		/// <param name="maxWidth">Maximum character width.</param>
		/// <param name="maxHeight">Maximum character height.</param>
		/// <returns>Maximum height above baseline.</returns>
		// Token: 0x06001AFC RID: 6908 RVA: 0x000A69C4 File Offset: 0x000A4BC4
		public HTuple GetFontExtents(out HTuple maxDescent, out HTuple maxWidth, out HTuple maxHeight)
		{
			IntPtr proc = HalconAPI.PreCall(1198);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, num, out maxDescent);
			num = HTuple.LoadNew(proc, 2, num, out maxWidth);
			num = HTuple.LoadNew(proc, 3, num, out maxHeight);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the maximum size of all characters of a font.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="maxDescent">Maximum extension below baseline.</param>
		/// <param name="maxWidth">Maximum character width.</param>
		/// <param name="maxHeight">Maximum character height.</param>
		/// <returns>Maximum height above baseline.</returns>
		// Token: 0x06001AFD RID: 6909 RVA: 0x000A6A44 File Offset: 0x000A4C44
		public int GetFontExtents(out int maxDescent, out int maxWidth, out int maxHeight)
		{
			IntPtr proc = HalconAPI.PreCall(1198);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HalconAPI.LoadI(proc, 1, num, out maxDescent);
			num = HalconAPI.LoadI(proc, 2, num, out maxWidth);
			num = HalconAPI.LoadI(proc, 3, num, out maxHeight);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the spatial size of a string.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="values">Values to consider. Default: "test_string"</param>
		/// <param name="descent">Maximum extension below baseline.</param>
		/// <param name="width">Text width.</param>
		/// <param name="height">Text height.</param>
		/// <returns>Maximum height above baseline.</returns>
		// Token: 0x06001AFE RID: 6910 RVA: 0x000A6AC4 File Offset: 0x000A4CC4
		public HTuple GetStringExtents(HTuple values, out HTuple descent, out HTuple width, out HTuple height)
		{
			IntPtr proc = HalconAPI.PreCall(1199);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, values);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(values);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, num, out descent);
			num = HTuple.LoadNew(proc, 2, num, out width);
			num = HTuple.LoadNew(proc, 3, num, out height);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the spatial size of a string.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="values">Values to consider. Default: "test_string"</param>
		/// <param name="descent">Maximum extension below baseline.</param>
		/// <param name="width">Text width.</param>
		/// <param name="height">Text height.</param>
		/// <returns>Maximum height above baseline.</returns>
		// Token: 0x06001AFF RID: 6911 RVA: 0x000A6B54 File Offset: 0x000A4D54
		public int GetStringExtents(string values, out int descent, out int width, out int height)
		{
			IntPtr proc = HalconAPI.PreCall(1199);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, values);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HalconAPI.LoadI(proc, 1, num, out descent);
			num = HalconAPI.LoadI(proc, 2, num, out width);
			num = HalconAPI.LoadI(proc, 3, num, out height);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Query the available fonts.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Tuple with available font names.</returns>
		// Token: 0x06001B00 RID: 6912 RVA: 0x000A6BDC File Offset: 0x000A4DDC
		public HTuple QueryFont()
		{
			IntPtr proc = HalconAPI.PreCall(1200);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Query all shapes available for text cursors.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Names of the available text cursors.</returns>
		// Token: 0x06001B01 RID: 6913 RVA: 0x000A6C24 File Offset: 0x000A4E24
		public HTuple QueryTshape()
		{
			IntPtr proc = HalconAPI.PreCall(1201);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Set the font used for text output.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="font">Name of new font.</param>
		// Token: 0x06001B02 RID: 6914 RVA: 0x000A6C6C File Offset: 0x000A4E6C
		public void SetFont(string font)
		{
			IntPtr proc = HalconAPI.PreCall(1202);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, font);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Get the current font.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Name of the current font.</returns>
		// Token: 0x06001B03 RID: 6915 RVA: 0x000A6CA8 File Offset: 0x000A4EA8
		public string GetFont()
		{
			IntPtr proc = HalconAPI.PreCall(1203);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get window parameters.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="param">Name of the parameter. Default: "flush"</param>
		/// <returns>Value of the parameter.</returns>
		// Token: 0x06001B04 RID: 6916 RVA: 0x000A6CF0 File Offset: 0x000A4EF0
		public HTuple GetWindowParam(string param)
		{
			IntPtr proc = HalconAPI.PreCall(1221);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, param);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Set window parameters.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="param">Name of the parameter. Default: "flush"</param>
		/// <param name="value">Value to be set. Default: "false"</param>
		// Token: 0x06001B05 RID: 6917 RVA: 0x000A6D40 File Offset: 0x000A4F40
		public void SetWindowParam(string param, HTuple value)
		{
			IntPtr proc = HalconAPI.PreCall(1222);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, param);
			HalconAPI.Store(proc, 2, value);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(value);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set window parameters.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="param">Name of the parameter. Default: "flush"</param>
		/// <param name="value">Value to be set. Default: "false"</param>
		// Token: 0x06001B06 RID: 6918 RVA: 0x000A6D8C File Offset: 0x000A4F8C
		public void SetWindowParam(string param, string value)
		{
			IntPtr proc = HalconAPI.PreCall(1222);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, param);
			HalconAPI.StoreS(proc, 2, value);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Define the region output shape.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="shape">Region output mode. Default: "original"</param>
		// Token: 0x06001B07 RID: 6919 RVA: 0x000A6DD0 File Offset: 0x000A4FD0
		public void SetShape(string shape)
		{
			IntPtr proc = HalconAPI.PreCall(1223);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, shape);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set the color definition via RGB values.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="red">Red component of the color. Default: 255</param>
		/// <param name="green">Green component of the color. Default: 0</param>
		/// <param name="blue">Blue component of the color. Default: 0</param>
		// Token: 0x06001B08 RID: 6920 RVA: 0x000A6E0C File Offset: 0x000A500C
		public void SetRgb(HTuple red, HTuple green, HTuple blue)
		{
			IntPtr proc = HalconAPI.PreCall(1224);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, red);
			HalconAPI.Store(proc, 2, green);
			HalconAPI.Store(proc, 3, blue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(red);
			HalconAPI.UnpinTuple(green);
			HalconAPI.UnpinTuple(blue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set the color definition via RGB values.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="red">Red component of the color. Default: 255</param>
		/// <param name="green">Green component of the color. Default: 0</param>
		/// <param name="blue">Blue component of the color. Default: 0</param>
		// Token: 0x06001B09 RID: 6921 RVA: 0x000A6E6C File Offset: 0x000A506C
		public void SetRgb(int red, int green, int blue)
		{
			IntPtr proc = HalconAPI.PreCall(1224);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, red);
			HalconAPI.StoreI(proc, 2, green);
			HalconAPI.StoreI(proc, 3, blue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Define a color lookup table index.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="pixel">Color lookup table index. Default: 128</param>
		// Token: 0x06001B0A RID: 6922 RVA: 0x000A6EB8 File Offset: 0x000A50B8
		public void SetPixel(HTuple pixel)
		{
			IntPtr proc = HalconAPI.PreCall(1225);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, pixel);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(pixel);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Define a color lookup table index.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="pixel">Color lookup table index. Default: 128</param>
		// Token: 0x06001B0B RID: 6923 RVA: 0x000A6EFC File Offset: 0x000A50FC
		public void SetPixel(int pixel)
		{
			IntPtr proc = HalconAPI.PreCall(1225);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, pixel);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Define an interpolation method for gray value output. 
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="style">Interpolation method for image output: 0 (fast, low quality) to 2 (slow, high quality). Default: 0</param>
		// Token: 0x06001B0C RID: 6924 RVA: 0x000A6F38 File Offset: 0x000A5138
		public void SetPartStyle(int style)
		{
			IntPtr proc = HalconAPI.PreCall(1226);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, style);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Modify the displayed image part.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1">Row of the upper left corner of the chosen image part. Default: 0</param>
		/// <param name="column1">Column of the upper left corner of the chosen image part. Default: 0</param>
		/// <param name="row2">Row of the lower right corner of the chosen image part. Default: -1</param>
		/// <param name="column2">Column of the lower right corner of the chosen image part. Default: -1</param>
		// Token: 0x06001B0D RID: 6925 RVA: 0x000A6F74 File Offset: 0x000A5174
		public void SetPart(HTuple row1, HTuple column1, HTuple row2, HTuple column2)
		{
			IntPtr proc = HalconAPI.PreCall(1227);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row1);
			HalconAPI.Store(proc, 2, column1);
			HalconAPI.Store(proc, 3, row2);
			HalconAPI.Store(proc, 4, column2);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Modify the displayed image part.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1">Row of the upper left corner of the chosen image part. Default: 0</param>
		/// <param name="column1">Column of the upper left corner of the chosen image part. Default: 0</param>
		/// <param name="row2">Row of the lower right corner of the chosen image part. Default: -1</param>
		/// <param name="column2">Column of the lower right corner of the chosen image part. Default: -1</param>
		// Token: 0x06001B0E RID: 6926 RVA: 0x000A6FE4 File Offset: 0x000A51E4
		public void SetPart(int row1, int column1, int row2, int column2)
		{
			IntPtr proc = HalconAPI.PreCall(1227);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, row1);
			HalconAPI.StoreI(proc, 2, column1);
			HalconAPI.StoreI(proc, 3, row2);
			HalconAPI.StoreI(proc, 4, column2);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Define the gray value output mode.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="mode">Output mode. Additional parameters possible. Default: "default"</param>
		// Token: 0x06001B0F RID: 6927 RVA: 0x000A703C File Offset: 0x000A523C
		public void SetPaint(HTuple mode)
		{
			IntPtr proc = HalconAPI.PreCall(1228);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, mode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(mode);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Define the line width for region contour output.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="width">Line width for region output in contour mode. Default: 1.0</param>
		// Token: 0x06001B10 RID: 6928 RVA: 0x000A7080 File Offset: 0x000A5280
		public void SetLineWidth(double width)
		{
			IntPtr proc = HalconAPI.PreCall(1229);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, width);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Define a contour output pattern.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="style">Contour pattern. Default: []</param>
		// Token: 0x06001B11 RID: 6929 RVA: 0x000A70BC File Offset: 0x000A52BC
		public void SetLineStyle(HTuple style)
		{
			IntPtr proc = HalconAPI.PreCall(1230);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, style);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(style);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Define the approximation error for contour display.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="approximation">Maximum deviation from the original contour. Default: 0</param>
		// Token: 0x06001B12 RID: 6930 RVA: 0x000A7100 File Offset: 0x000A5300
		public void SetLineApprox(int approximation)
		{
			IntPtr proc = HalconAPI.PreCall(1231);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, approximation);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Define the pixel output function.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="mode">Name of the display function. Default: "copy"</param>
		// Token: 0x06001B13 RID: 6931 RVA: 0x000A713C File Offset: 0x000A533C
		public void SetInsert(string mode)
		{
			IntPtr proc = HalconAPI.PreCall(1232);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, mode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Define output colors (HSI-coded).
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="hue">Hue for region output. Default: 30</param>
		/// <param name="saturation">Saturation for region output. Default: 255</param>
		/// <param name="intensity">Intensity for region output. Default: 84</param>
		// Token: 0x06001B14 RID: 6932 RVA: 0x000A7178 File Offset: 0x000A5378
		public void SetHsi(HTuple hue, HTuple saturation, HTuple intensity)
		{
			IntPtr proc = HalconAPI.PreCall(1233);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, hue);
			HalconAPI.Store(proc, 2, saturation);
			HalconAPI.Store(proc, 3, intensity);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(hue);
			HalconAPI.UnpinTuple(saturation);
			HalconAPI.UnpinTuple(intensity);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Define output colors (HSI-coded).
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="hue">Hue for region output. Default: 30</param>
		/// <param name="saturation">Saturation for region output. Default: 255</param>
		/// <param name="intensity">Intensity for region output. Default: 84</param>
		// Token: 0x06001B15 RID: 6933 RVA: 0x000A71D8 File Offset: 0x000A53D8
		public void SetHsi(int hue, int saturation, int intensity)
		{
			IntPtr proc = HalconAPI.PreCall(1233);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, hue);
			HalconAPI.StoreI(proc, 2, saturation);
			HalconAPI.StoreI(proc, 3, intensity);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Define gray values for region output.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="grayValues">Gray values for region output. Default: 255</param>
		// Token: 0x06001B16 RID: 6934 RVA: 0x000A7224 File Offset: 0x000A5424
		public void SetGray(HTuple grayValues)
		{
			IntPtr proc = HalconAPI.PreCall(1234);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, grayValues);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(grayValues);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Define gray values for region output.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="grayValues">Gray values for region output. Default: 255</param>
		// Token: 0x06001B17 RID: 6935 RVA: 0x000A7268 File Offset: 0x000A5468
		public void SetGray(int grayValues)
		{
			IntPtr proc = HalconAPI.PreCall(1234);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, grayValues);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Define the region fill mode.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="mode">Fill mode for region output. Default: "fill"</param>
		// Token: 0x06001B18 RID: 6936 RVA: 0x000A72A4 File Offset: 0x000A54A4
		public void SetDraw(string mode)
		{
			IntPtr proc = HalconAPI.PreCall(1235);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, mode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Define the image matrix output clipping.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="mode">Clipping mode for gray value output. Default: "object"</param>
		// Token: 0x06001B19 RID: 6937 RVA: 0x000A72E0 File Offset: 0x000A54E0
		public void SetComprise(string mode)
		{
			IntPtr proc = HalconAPI.PreCall(1236);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, mode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set multiple output colors.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="numberOfColors">Number of output colors. Default: 12</param>
		// Token: 0x06001B1A RID: 6938 RVA: 0x000A731C File Offset: 0x000A551C
		public void SetColored(int numberOfColors)
		{
			IntPtr proc = HalconAPI.PreCall(1237);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, numberOfColors);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set output color.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="color">Output color names. Default: "white"</param>
		// Token: 0x06001B1B RID: 6939 RVA: 0x000A7358 File Offset: 0x000A5558
		public void SetColor(HTuple color)
		{
			IntPtr proc = HalconAPI.PreCall(1238);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, color);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(color);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set output color.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="color">Output color names. Default: "white"</param>
		// Token: 0x06001B1C RID: 6940 RVA: 0x000A739C File Offset: 0x000A559C
		public void SetColor(string color)
		{
			IntPtr proc = HalconAPI.PreCall(1238);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, color);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Get the current region output shape.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Current region output shape.</returns>
		// Token: 0x06001B1D RID: 6941 RVA: 0x000A73D8 File Offset: 0x000A55D8
		public string GetShape()
		{
			IntPtr proc = HalconAPI.PreCall(1239);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the current color in RGB-coding.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="red">The current color's red value.</param>
		/// <param name="green">The current color's green value.</param>
		/// <param name="blue">The current color's blue value.</param>
		// Token: 0x06001B1E RID: 6942 RVA: 0x000A7420 File Offset: 0x000A5620
		public void GetRgb(out HTuple red, out HTuple green, out HTuple blue)
		{
			IntPtr proc = HalconAPI.PreCall(1240);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out red);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out green);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out blue);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Get the current color lookup table index.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Index of the current color look-up table.</returns>
		// Token: 0x06001B1F RID: 6943 RVA: 0x000A7490 File Offset: 0x000A5690
		public HTuple GetPixel()
		{
			IntPtr proc = HalconAPI.PreCall(1241);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the current interpolation mode for gray value display.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Interpolation mode for image display: 0 (fast, low quality) to 2 (slow, high quality).</returns>
		// Token: 0x06001B20 RID: 6944 RVA: 0x000A74DC File Offset: 0x000A56DC
		public int GetPartStyle()
		{
			IntPtr proc = HalconAPI.PreCall(1242);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the image part.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1">Row index of the image part's upper left corner.</param>
		/// <param name="column1">Column index of the image part's upper left corner.</param>
		/// <param name="row2">Row index of the image part's lower right corner.</param>
		/// <param name="column2">Column index of the image part's lower right corner.</param>
		// Token: 0x06001B21 RID: 6945 RVA: 0x000A7524 File Offset: 0x000A5724
		public void GetPart(out HTuple row1, out HTuple column1, out HTuple row2, out HTuple column2)
		{
			IntPtr proc = HalconAPI.PreCall(1243);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, num, out row1);
			num = HTuple.LoadNew(proc, 1, num, out column1);
			num = HTuple.LoadNew(proc, 2, num, out row2);
			num = HTuple.LoadNew(proc, 3, num, out column2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Get the image part.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1">Row index of the image part's upper left corner.</param>
		/// <param name="column1">Column index of the image part's upper left corner.</param>
		/// <param name="row2">Row index of the image part's lower right corner.</param>
		/// <param name="column2">Column index of the image part's lower right corner.</param>
		// Token: 0x06001B22 RID: 6946 RVA: 0x000A75A4 File Offset: 0x000A57A4
		public void GetPart(out int row1, out int column1, out int row2, out int column2)
		{
			IntPtr proc = HalconAPI.PreCall(1243);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out row1);
			num = HalconAPI.LoadI(proc, 1, num, out column1);
			num = HalconAPI.LoadI(proc, 2, num, out row2);
			num = HalconAPI.LoadI(proc, 3, num, out column2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Get the current display mode for gray values.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Name and parameter values of the current display mode.</returns>
		// Token: 0x06001B23 RID: 6947 RVA: 0x000A7624 File Offset: 0x000A5824
		public HTuple GetPaint()
		{
			IntPtr proc = HalconAPI.PreCall(1244);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the current line width for contour display.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Current line width for contour display.</returns>
		// Token: 0x06001B24 RID: 6948 RVA: 0x000A766C File Offset: 0x000A586C
		public double GetLineWidth()
		{
			IntPtr proc = HalconAPI.PreCall(1245);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the current graphic mode for contours.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Template for contour display.</returns>
		// Token: 0x06001B25 RID: 6949 RVA: 0x000A76B4 File Offset: 0x000A58B4
		public HTuple GetLineStyle()
		{
			IntPtr proc = HalconAPI.PreCall(1246);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the current approximation error for contour display.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Current approximation error for contour display.</returns>
		// Token: 0x06001B26 RID: 6950 RVA: 0x000A7700 File Offset: 0x000A5900
		public int GetLineApprox()
		{
			IntPtr proc = HalconAPI.PreCall(1247);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the current display mode.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Display mode.</returns>
		// Token: 0x06001B27 RID: 6951 RVA: 0x000A7748 File Offset: 0x000A5948
		public string GetInsert()
		{
			IntPtr proc = HalconAPI.PreCall(1248);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the HSI coding of the current color.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="saturation">Saturation of the current color.</param>
		/// <param name="intensity">Intensity of the current color.</param>
		/// <returns>Hue (color value) of the current color.</returns>
		// Token: 0x06001B28 RID: 6952 RVA: 0x000A7790 File Offset: 0x000A5990
		public HTuple GetHsi(out HTuple saturation, out HTuple intensity)
		{
			IntPtr proc = HalconAPI.PreCall(1249);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out saturation);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out intensity);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the current region fill mode.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Current region fill mode.</returns>
		// Token: 0x06001B29 RID: 6953 RVA: 0x000A7800 File Offset: 0x000A5A00
		public string GetDraw()
		{
			IntPtr proc = HalconAPI.PreCall(1250);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Query the gray value display modes.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Gray value display mode names.</returns>
		// Token: 0x06001B2A RID: 6954 RVA: 0x000A7848 File Offset: 0x000A5A48
		public HTuple QueryPaint()
		{
			IntPtr proc = HalconAPI.PreCall(1253);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Query the possible graphic modes.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Display function name.</returns>
		// Token: 0x06001B2B RID: 6955 RVA: 0x000A7890 File Offset: 0x000A5A90
		public HTuple QueryInsert()
		{
			IntPtr proc = HalconAPI.PreCall(1255);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Query the displayable gray values.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Tuple of all displayable gray values.</returns>
		// Token: 0x06001B2C RID: 6956 RVA: 0x000A78D8 File Offset: 0x000A5AD8
		public HTuple QueryGray()
		{
			IntPtr proc = HalconAPI.PreCall(1256);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Query all color names.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Color names.</returns>
		// Token: 0x06001B2D RID: 6957 RVA: 0x000A7924 File Offset: 0x000A5B24
		public HTuple QueryAllColors()
		{
			IntPtr proc = HalconAPI.PreCall(1258);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Query all color names displayable in the window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Color names.</returns>
		// Token: 0x06001B2E RID: 6958 RVA: 0x000A796C File Offset: 0x000A5B6C
		public HTuple QueryColor()
		{
			IntPtr proc = HalconAPI.PreCall(1259);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Query the icon for region output
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Icon for the regions center of gravity.</returns>
		// Token: 0x06001B2F RID: 6959 RVA: 0x000A79B4 File Offset: 0x000A5BB4
		public HRegion GetIcon()
		{
			IntPtr proc = HalconAPI.PreCall(1260);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Icon definition for region output.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="icon">Icon for center of gravity.</param>
		// Token: 0x06001B30 RID: 6960 RVA: 0x000A79FC File Offset: 0x000A5BFC
		public void SetIcon(HRegion icon)
		{
			IntPtr proc = HalconAPI.PreCall(1261);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, icon);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(icon);
		}

		/// <summary>
		///   Displays regions in a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="dispRegions">Regions to display.</param>
		// Token: 0x06001B31 RID: 6961 RVA: 0x000A7A40 File Offset: 0x000A5C40
		public void DispRegion(HRegion dispRegions)
		{
			IntPtr proc = HalconAPI.PreCall(1262);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, dispRegions);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(dispRegions);
		}

		/// <summary>
		///   Displays arbitrarily oriented rectangles.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="centerRow">Row index of the center. Default: 48</param>
		/// <param name="centerCol">Column index of the center. Default: 64</param>
		/// <param name="phi">Orientation of rectangle in radians. Default: 0.0</param>
		/// <param name="length1">Half of the length of the longer side. Default: 48</param>
		/// <param name="length2">Half of the length of the shorter side. Default: 32</param>
		// Token: 0x06001B32 RID: 6962 RVA: 0x000A7A84 File Offset: 0x000A5C84
		public void DispRectangle2(HTuple centerRow, HTuple centerCol, HTuple phi, HTuple length1, HTuple length2)
		{
			IntPtr proc = HalconAPI.PreCall(1263);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, centerRow);
			HalconAPI.Store(proc, 2, centerCol);
			HalconAPI.Store(proc, 3, phi);
			HalconAPI.Store(proc, 4, length1);
			HalconAPI.Store(proc, 5, length2);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(centerRow);
			HalconAPI.UnpinTuple(centerCol);
			HalconAPI.UnpinTuple(phi);
			HalconAPI.UnpinTuple(length1);
			HalconAPI.UnpinTuple(length2);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Displays arbitrarily oriented rectangles.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="centerRow">Row index of the center. Default: 48</param>
		/// <param name="centerCol">Column index of the center. Default: 64</param>
		/// <param name="phi">Orientation of rectangle in radians. Default: 0.0</param>
		/// <param name="length1">Half of the length of the longer side. Default: 48</param>
		/// <param name="length2">Half of the length of the shorter side. Default: 32</param>
		// Token: 0x06001B33 RID: 6963 RVA: 0x000A7B04 File Offset: 0x000A5D04
		public void DispRectangle2(double centerRow, double centerCol, double phi, double length1, double length2)
		{
			IntPtr proc = HalconAPI.PreCall(1263);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, centerRow);
			HalconAPI.StoreD(proc, 2, centerCol);
			HalconAPI.StoreD(proc, 3, phi);
			HalconAPI.StoreD(proc, 4, length1);
			HalconAPI.StoreD(proc, 5, length2);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Display of rectangles aligned to the coordinate axes.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1">Row index of the upper left corner. Default: 16</param>
		/// <param name="column1">Column index of the upper left corner. Default: 16</param>
		/// <param name="row2">Row index of the lower right corner. Default: 48</param>
		/// <param name="column2">Column index of the lower right corner. Default: 80</param>
		// Token: 0x06001B34 RID: 6964 RVA: 0x000A7B64 File Offset: 0x000A5D64
		public void DispRectangle1(HTuple row1, HTuple column1, HTuple row2, HTuple column2)
		{
			IntPtr proc = HalconAPI.PreCall(1264);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row1);
			HalconAPI.Store(proc, 2, column1);
			HalconAPI.Store(proc, 3, row2);
			HalconAPI.Store(proc, 4, column2);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Display of rectangles aligned to the coordinate axes.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1">Row index of the upper left corner. Default: 16</param>
		/// <param name="column1">Column index of the upper left corner. Default: 16</param>
		/// <param name="row2">Row index of the lower right corner. Default: 48</param>
		/// <param name="column2">Column index of the lower right corner. Default: 80</param>
		// Token: 0x06001B35 RID: 6965 RVA: 0x000A7BD4 File Offset: 0x000A5DD4
		public void DispRectangle1(double row1, double column1, double row2, double column2)
		{
			IntPtr proc = HalconAPI.PreCall(1264);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, row1);
			HalconAPI.StoreD(proc, 2, column1);
			HalconAPI.StoreD(proc, 3, row2);
			HalconAPI.StoreD(proc, 4, column2);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Displays a polyline.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row index Default: [16,80,80]</param>
		/// <param name="column">Column index Default: [48,16,80]</param>
		// Token: 0x06001B36 RID: 6966 RVA: 0x000A7C2C File Offset: 0x000A5E2C
		public void DispPolygon(HTuple row, HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1265);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Draws lines in a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1">Row index of the start. Default: 32.0</param>
		/// <param name="column1">Column index of the start. Default: 32.0</param>
		/// <param name="row2">Row index of end. Default: 64.0</param>
		/// <param name="column2">Column index of end. Default: 64.0</param>
		// Token: 0x06001B37 RID: 6967 RVA: 0x000A7C7C File Offset: 0x000A5E7C
		public void DispLine(HTuple row1, HTuple column1, HTuple row2, HTuple column2)
		{
			IntPtr proc = HalconAPI.PreCall(1266);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row1);
			HalconAPI.Store(proc, 2, column1);
			HalconAPI.Store(proc, 3, row2);
			HalconAPI.Store(proc, 4, column2);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Draws lines in a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1">Row index of the start. Default: 32.0</param>
		/// <param name="column1">Column index of the start. Default: 32.0</param>
		/// <param name="row2">Row index of end. Default: 64.0</param>
		/// <param name="column2">Column index of end. Default: 64.0</param>
		// Token: 0x06001B38 RID: 6968 RVA: 0x000A7CEC File Offset: 0x000A5EEC
		public void DispLine(double row1, double column1, double row2, double column2)
		{
			IntPtr proc = HalconAPI.PreCall(1266);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, row1);
			HalconAPI.StoreD(proc, 2, column1);
			HalconAPI.StoreD(proc, 3, row2);
			HalconAPI.StoreD(proc, 4, column2);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Displays crosses in a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row coordinate of the center. Default: 32.0</param>
		/// <param name="column">Column coordinate of the center. Default: 32.0</param>
		/// <param name="size">Length of the bars. Default: 6.0</param>
		/// <param name="angle">Orientation. Default: 0.0</param>
		// Token: 0x06001B39 RID: 6969 RVA: 0x000A7D44 File Offset: 0x000A5F44
		public void DispCross(HTuple row, HTuple column, double size, double angle)
		{
			IntPtr proc = HalconAPI.PreCall(1267);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			HalconAPI.StoreD(proc, 3, size);
			HalconAPI.StoreD(proc, 4, angle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Displays crosses in a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row coordinate of the center. Default: 32.0</param>
		/// <param name="column">Column coordinate of the center. Default: 32.0</param>
		/// <param name="size">Length of the bars. Default: 6.0</param>
		/// <param name="angle">Orientation. Default: 0.0</param>
		// Token: 0x06001B3A RID: 6970 RVA: 0x000A7DA8 File Offset: 0x000A5FA8
		public void DispCross(double row, double column, double size, double angle)
		{
			IntPtr proc = HalconAPI.PreCall(1267);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, row);
			HalconAPI.StoreD(proc, 2, column);
			HalconAPI.StoreD(proc, 3, size);
			HalconAPI.StoreD(proc, 4, angle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Displays gray value images.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="image">Gray value image to display.</param>
		// Token: 0x06001B3B RID: 6971 RVA: 0x000A7E00 File Offset: 0x000A6000
		public void DispImage(HImage image)
		{
			IntPtr proc = HalconAPI.PreCall(1268);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Displays images with several channels.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="multichannelImage">Multichannel images to be displayed.</param>
		/// <param name="channel">Number of channel or the numbers of the RGB-channels Default: 1</param>
		// Token: 0x06001B3C RID: 6972 RVA: 0x000A7E44 File Offset: 0x000A6044
		public void DispChannel(HImage multichannelImage, HTuple channel)
		{
			IntPtr proc = HalconAPI.PreCall(1269);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, multichannelImage);
			HalconAPI.Store(proc, 1, channel);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(channel);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(multichannelImage);
		}

		/// <summary>
		///   Displays images with several channels.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="multichannelImage">Multichannel images to be displayed.</param>
		/// <param name="channel">Number of channel or the numbers of the RGB-channels Default: 1</param>
		// Token: 0x06001B3D RID: 6973 RVA: 0x000A7E94 File Offset: 0x000A6094
		public void DispChannel(HImage multichannelImage, int channel)
		{
			IntPtr proc = HalconAPI.PreCall(1269);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, multichannelImage);
			HalconAPI.StoreI(proc, 1, channel);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(multichannelImage);
		}

		/// <summary>
		///   Displays a color (RGB) image
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="colorImage">Color image to display.</param>
		// Token: 0x06001B3E RID: 6974 RVA: 0x000A7EE0 File Offset: 0x000A60E0
		public void DispColor(HImage colorImage)
		{
			IntPtr proc = HalconAPI.PreCall(1270);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, colorImage);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(colorImage);
		}

		/// <summary>
		///   Displays ellipses.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="centerRow">Row index of center. Default: 64</param>
		/// <param name="centerCol">Column index of center. Default: 64</param>
		/// <param name="phi">Orientation of the ellipse in radians Default: 0.0</param>
		/// <param name="radius1">Radius of major axis. Default: 24.0</param>
		/// <param name="radius2">Radius of minor axis. Default: 14.0</param>
		// Token: 0x06001B3F RID: 6975 RVA: 0x000A7F24 File Offset: 0x000A6124
		public void DispEllipse(HTuple centerRow, HTuple centerCol, HTuple phi, HTuple radius1, HTuple radius2)
		{
			IntPtr proc = HalconAPI.PreCall(1271);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, centerRow);
			HalconAPI.Store(proc, 2, centerCol);
			HalconAPI.Store(proc, 3, phi);
			HalconAPI.Store(proc, 4, radius1);
			HalconAPI.Store(proc, 5, radius2);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(centerRow);
			HalconAPI.UnpinTuple(centerCol);
			HalconAPI.UnpinTuple(phi);
			HalconAPI.UnpinTuple(radius1);
			HalconAPI.UnpinTuple(radius2);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Displays ellipses.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="centerRow">Row index of center. Default: 64</param>
		/// <param name="centerCol">Column index of center. Default: 64</param>
		/// <param name="phi">Orientation of the ellipse in radians Default: 0.0</param>
		/// <param name="radius1">Radius of major axis. Default: 24.0</param>
		/// <param name="radius2">Radius of minor axis. Default: 14.0</param>
		// Token: 0x06001B40 RID: 6976 RVA: 0x000A7FA4 File Offset: 0x000A61A4
		public void DispEllipse(int centerRow, int centerCol, double phi, double radius1, double radius2)
		{
			IntPtr proc = HalconAPI.PreCall(1271);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, centerRow);
			HalconAPI.StoreI(proc, 2, centerCol);
			HalconAPI.StoreD(proc, 3, phi);
			HalconAPI.StoreD(proc, 4, radius1);
			HalconAPI.StoreD(proc, 5, radius2);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Displays a noise distribution.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="distribution">Gray value distribution (513 values).</param>
		/// <param name="row">Row index of center. Default: 256</param>
		/// <param name="column">Column index of center. Default: 256</param>
		/// <param name="scale">Size of display. Default: 1</param>
		// Token: 0x06001B41 RID: 6977 RVA: 0x000A8004 File Offset: 0x000A6204
		public void DispDistribution(HTuple distribution, int row, int column, int scale)
		{
			IntPtr proc = HalconAPI.PreCall(1272);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, distribution);
			HalconAPI.StoreI(proc, 2, row);
			HalconAPI.StoreI(proc, 3, column);
			HalconAPI.StoreI(proc, 4, scale);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(distribution);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Displays circles in a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row index of the center. Default: 64</param>
		/// <param name="column">Column index of the center. Default: 64</param>
		/// <param name="radius">Radius of the circle. Default: 64</param>
		// Token: 0x06001B42 RID: 6978 RVA: 0x000A8060 File Offset: 0x000A6260
		public void DispCircle(HTuple row, HTuple column, HTuple radius)
		{
			IntPtr proc = HalconAPI.PreCall(1273);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			HalconAPI.Store(proc, 3, radius);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(radius);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Displays circles in a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row index of the center. Default: 64</param>
		/// <param name="column">Column index of the center. Default: 64</param>
		/// <param name="radius">Radius of the circle. Default: 64</param>
		// Token: 0x06001B43 RID: 6979 RVA: 0x000A80C0 File Offset: 0x000A62C0
		public void DispCircle(double row, double column, double radius)
		{
			IntPtr proc = HalconAPI.PreCall(1273);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, row);
			HalconAPI.StoreD(proc, 2, column);
			HalconAPI.StoreD(proc, 3, radius);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Displays arrows in a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1">Row index of the start. Default: 10.0</param>
		/// <param name="column1">Column index of the start. Default: 10.0</param>
		/// <param name="row2">Row index of the end. Default: 118.0</param>
		/// <param name="column2">Column index of the end. Default: 118.0</param>
		/// <param name="size">Size of the arrowhead. Default: 1.0</param>
		// Token: 0x06001B44 RID: 6980 RVA: 0x000A810C File Offset: 0x000A630C
		public void DispArrow(HTuple row1, HTuple column1, HTuple row2, HTuple column2, HTuple size)
		{
			IntPtr proc = HalconAPI.PreCall(1274);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row1);
			HalconAPI.Store(proc, 2, column1);
			HalconAPI.Store(proc, 3, row2);
			HalconAPI.Store(proc, 4, column2);
			HalconAPI.Store(proc, 5, size);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			HalconAPI.UnpinTuple(size);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Displays arrows in a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1">Row index of the start. Default: 10.0</param>
		/// <param name="column1">Column index of the start. Default: 10.0</param>
		/// <param name="row2">Row index of the end. Default: 118.0</param>
		/// <param name="column2">Column index of the end. Default: 118.0</param>
		/// <param name="size">Size of the arrowhead. Default: 1.0</param>
		// Token: 0x06001B45 RID: 6981 RVA: 0x000A818C File Offset: 0x000A638C
		public void DispArrow(double row1, double column1, double row2, double column2, double size)
		{
			IntPtr proc = HalconAPI.PreCall(1274);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, row1);
			HalconAPI.StoreD(proc, 2, column1);
			HalconAPI.StoreD(proc, 3, row2);
			HalconAPI.StoreD(proc, 4, column2);
			HalconAPI.StoreD(proc, 5, size);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Displays circular arcs in a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="centerRow">Row coordinate of center point. Default: 64</param>
		/// <param name="centerCol">Column coordinate of center point. Default: 64</param>
		/// <param name="angle">Angle between start and end of the arc (in radians). Default: 3.1415926</param>
		/// <param name="beginRow">Row coordinate of the start of the arc. Default: 32</param>
		/// <param name="beginCol">Column coordinate of the start of the arc. Default: 32</param>
		// Token: 0x06001B46 RID: 6982 RVA: 0x000A81EC File Offset: 0x000A63EC
		public void DispArc(HTuple centerRow, HTuple centerCol, HTuple angle, HTuple beginRow, HTuple beginCol)
		{
			IntPtr proc = HalconAPI.PreCall(1275);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, centerRow);
			HalconAPI.Store(proc, 2, centerCol);
			HalconAPI.Store(proc, 3, angle);
			HalconAPI.Store(proc, 4, beginRow);
			HalconAPI.Store(proc, 5, beginCol);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(centerRow);
			HalconAPI.UnpinTuple(centerCol);
			HalconAPI.UnpinTuple(angle);
			HalconAPI.UnpinTuple(beginRow);
			HalconAPI.UnpinTuple(beginCol);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Displays circular arcs in a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="centerRow">Row coordinate of center point. Default: 64</param>
		/// <param name="centerCol">Column coordinate of center point. Default: 64</param>
		/// <param name="angle">Angle between start and end of the arc (in radians). Default: 3.1415926</param>
		/// <param name="beginRow">Row coordinate of the start of the arc. Default: 32</param>
		/// <param name="beginCol">Column coordinate of the start of the arc. Default: 32</param>
		// Token: 0x06001B47 RID: 6983 RVA: 0x000A826C File Offset: 0x000A646C
		public void DispArc(double centerRow, double centerCol, double angle, int beginRow, int beginCol)
		{
			IntPtr proc = HalconAPI.PreCall(1275);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, centerRow);
			HalconAPI.StoreD(proc, 2, centerCol);
			HalconAPI.StoreD(proc, 3, angle);
			HalconAPI.StoreI(proc, 4, beginRow);
			HalconAPI.StoreI(proc, 5, beginCol);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Displays image objects (image, region, XLD).
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="objectVal">Image object to be displayed.</param>
		// Token: 0x06001B48 RID: 6984 RVA: 0x000A82CC File Offset: 0x000A64CC
		public void DispObj(HObject objectVal)
		{
			IntPtr proc = HalconAPI.PreCall(1276);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, objectVal);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(objectVal);
		}

		/// <summary>
		///   Set the current mouse pointer shape.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="cursor">Mouse pointer name. Default: "arrow"</param>
		// Token: 0x06001B49 RID: 6985 RVA: 0x000A8310 File Offset: 0x000A6510
		public void SetMshape(string cursor)
		{
			IntPtr proc = HalconAPI.PreCall(1277);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, cursor);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Query the current mouse pointer shape.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Mouse pointer name.</returns>
		// Token: 0x06001B4A RID: 6986 RVA: 0x000A834C File Offset: 0x000A654C
		public string GetMshape()
		{
			IntPtr proc = HalconAPI.PreCall(1278);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Query all available mouse pointer shapes.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Available mouse pointer names.</returns>
		// Token: 0x06001B4B RID: 6987 RVA: 0x000A8394 File Offset: 0x000A6594
		public HTuple QueryMshape()
		{
			IntPtr proc = HalconAPI.PreCall(1279);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Query the subpixel mouse position.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="column">Column coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="button">Mouse button(s) pressed or 0.</param>
		// Token: 0x06001B4C RID: 6988 RVA: 0x000A83DC File Offset: 0x000A65DC
		public void GetMpositionSubPix(out double row, out double column, out int button)
		{
			IntPtr proc = HalconAPI.PreCall(1280);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadI(proc, 2, num, out button);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Query the mouse position.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="column">Column coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="button">Mouse button(s) pressed or 0.</param>
		// Token: 0x06001B4D RID: 6989 RVA: 0x000A8448 File Offset: 0x000A6648
		public void GetMposition(out int row, out int column, out int button)
		{
			IntPtr proc = HalconAPI.PreCall(1281);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out row);
			num = HalconAPI.LoadI(proc, 1, num, out column);
			num = HalconAPI.LoadI(proc, 2, num, out button);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Wait until a mouse button is pressed and get the subpixel mouse position.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="column">Column coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="button">Mouse button(s) pressed.</param>
		// Token: 0x06001B4E RID: 6990 RVA: 0x000A84B4 File Offset: 0x000A66B4
		public void GetMbuttonSubPix(out double row, out double column, out int button)
		{
			IntPtr proc = HalconAPI.PreCall(1282);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadI(proc, 2, num, out button);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Wait until a mouse button is pressed.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="column">Column coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="button">Mouse button(s) pressed.</param>
		// Token: 0x06001B4F RID: 6991 RVA: 0x000A8520 File Offset: 0x000A6720
		public void GetMbutton(out int row, out int column, out int button)
		{
			IntPtr proc = HalconAPI.PreCall(1283);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out row);
			num = HalconAPI.LoadI(proc, 1, num, out column);
			num = HalconAPI.LoadI(proc, 2, num, out button);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Write look-up-table (lut) as file.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="fileName">File name (of file containing the look-up-table). Default: "/tmp/lut"</param>
		// Token: 0x06001B50 RID: 6992 RVA: 0x000A858C File Offset: 0x000A678C
		public void WriteLut(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(1284);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Graphical view of the look-up-table (lut).
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row of centre of the graphic. Default: 128</param>
		/// <param name="column">Column of centre of the graphic. Default: 128</param>
		/// <param name="scale">Scaling of the graphic. Default: 1</param>
		// Token: 0x06001B51 RID: 6993 RVA: 0x000A85C8 File Offset: 0x000A67C8
		public void DispLut(int row, int column, int scale)
		{
			IntPtr proc = HalconAPI.PreCall(1285);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.StoreI(proc, 3, scale);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Query all available look-up-tables (lut).
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Names of look-up-tables.</returns>
		// Token: 0x06001B52 RID: 6994 RVA: 0x000A8614 File Offset: 0x000A6814
		public HTuple QueryLut()
		{
			IntPtr proc = HalconAPI.PreCall(1286);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get modification parameters of look-up-table (lut).
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="saturation">Modification of saturation.</param>
		/// <param name="intensity">Modification of intensity.</param>
		/// <returns>Modification of color value.</returns>
		// Token: 0x06001B53 RID: 6995 RVA: 0x000A865C File Offset: 0x000A685C
		public double GetLutStyle(out double saturation, out double intensity)
		{
			IntPtr proc = HalconAPI.PreCall(1287);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out saturation);
			num = HalconAPI.LoadD(proc, 2, num, out intensity);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Changing the look-up-table (lut).
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="hue">Modification of color value. Default: 0.0</param>
		/// <param name="saturation">Modification of saturation. Default: 1.5</param>
		/// <param name="intensity">Modification of intensity. Default: 1.5</param>
		// Token: 0x06001B54 RID: 6996 RVA: 0x000A86C8 File Offset: 0x000A68C8
		public void SetLutStyle(double hue, double saturation, double intensity)
		{
			IntPtr proc = HalconAPI.PreCall(1288);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, hue);
			HalconAPI.StoreD(proc, 2, saturation);
			HalconAPI.StoreD(proc, 3, intensity);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Get current look-up-table (lut).
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Name of look-up-table or tuple of RGB-values.</returns>
		// Token: 0x06001B55 RID: 6997 RVA: 0x000A8714 File Offset: 0x000A6914
		public HTuple GetLut()
		{
			IntPtr proc = HalconAPI.PreCall(1289);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Set "`look-up-table"' (lut).
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="lookUpTable">Name of look-up-table, values of look-up-table (RGB) or file name. Default: "default"</param>
		// Token: 0x06001B56 RID: 6998 RVA: 0x000A875C File Offset: 0x000A695C
		public void SetLut(HTuple lookUpTable)
		{
			IntPtr proc = HalconAPI.PreCall(1290);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, lookUpTable);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(lookUpTable);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set "`look-up-table"' (lut).
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="lookUpTable">Name of look-up-table, values of look-up-table (RGB) or file name. Default: "default"</param>
		// Token: 0x06001B57 RID: 6999 RVA: 0x000A87A0 File Offset: 0x000A69A0
		public void SetLut(string lookUpTable)
		{
			IntPtr proc = HalconAPI.PreCall(1290);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, lookUpTable);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Get mode of fixing of current look-up-table (lut).
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Current Mode of fixing.</returns>
		// Token: 0x06001B58 RID: 7000 RVA: 0x000A87DC File Offset: 0x000A69DC
		public string GetFix()
		{
			IntPtr proc = HalconAPI.PreCall(1291);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Set fixing of "`look-up-table"' (lut)
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="mode">Mode of fixing. Default: "true"</param>
		// Token: 0x06001B59 RID: 7001 RVA: 0x000A8824 File Offset: 0x000A6A24
		public void SetFix(string mode)
		{
			IntPtr proc = HalconAPI.PreCall(1292);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, mode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Get fixing of "`look-up-table"' (lut) for "`real color images"'
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Mode of fixing.</returns>
		// Token: 0x06001B5A RID: 7002 RVA: 0x000A8860 File Offset: 0x000A6A60
		public string GetFixedLut()
		{
			IntPtr proc = HalconAPI.PreCall(1293);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Fix "`look-up-table"' (lut) for "`real color images"'.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="mode">Mode of fixing. Default: "true"</param>
		// Token: 0x06001B5B RID: 7003 RVA: 0x000A88A8 File Offset: 0x000A6AA8
		public void SetFixedLut(string mode)
		{
			IntPtr proc = HalconAPI.PreCall(1294);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, mode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Interactive movement of a region with restriction of positions.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="sourceRegion">Regions to move.</param>
		/// <param name="maskRegion">Points on which it is allowed for a region to move.</param>
		/// <param name="row">Row index of the reference point. Default: 100</param>
		/// <param name="column">Column index of the reference point. Default: 100</param>
		/// <returns>Moved regions.</returns>
		// Token: 0x06001B5C RID: 7004 RVA: 0x000A88E4 File Offset: 0x000A6AE4
		public HRegion DragRegion3(HRegion sourceRegion, HRegion maskRegion, int row, int column)
		{
			IntPtr proc = HalconAPI.PreCall(1315);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, sourceRegion);
			HalconAPI.Store(proc, 2, maskRegion);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(sourceRegion);
			GC.KeepAlive(maskRegion);
			return result;
		}

		/// <summary>
		///   Interactive movement of a region with fixpoint specification.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="sourceRegion">Regions to move.</param>
		/// <param name="row">Row index of the reference point. Default: 100</param>
		/// <param name="column">Column index of the reference point. Default: 100</param>
		/// <returns>Moved regions.</returns>
		// Token: 0x06001B5D RID: 7005 RVA: 0x000A895C File Offset: 0x000A6B5C
		public HRegion DragRegion2(HRegion sourceRegion, int row, int column)
		{
			IntPtr proc = HalconAPI.PreCall(1316);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, sourceRegion);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(sourceRegion);
			return result;
		}

		/// <summary>
		///   Interactive moving of a region.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="sourceRegion">Regions to move.</param>
		/// <returns>Moved Regions.</returns>
		// Token: 0x06001B5E RID: 7006 RVA: 0x000A89C4 File Offset: 0x000A6BC4
		public HRegion DragRegion1(HRegion sourceRegion)
		{
			IntPtr proc = HalconAPI.PreCall(1317);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, sourceRegion);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(sourceRegion);
			return result;
		}

		/// <summary>
		///   Interactive modification of a NURBS curve using interpolation.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="rotate">Enable rotation? Default: "true"</param>
		/// <param name="move">Enable moving? Default: "true"</param>
		/// <param name="scale">Enable scaling? Default: "true"</param>
		/// <param name="keepRatio">Keep ratio while scaling? Default: "true"</param>
		/// <param name="edit">Enable editing? Default: "true"</param>
		/// <param name="degree">The degree $p$ of the NURBS curve. Reasonable values are 3 to 5. Default: 3</param>
		/// <param name="rowsIn">Row coordinates of the input interpolation points.</param>
		/// <param name="colsIn">Column coordinates of the input interpolation points.</param>
		/// <param name="tangentsIn">Input tangents.</param>
		/// <param name="controlRows">Row coordinates of the control polygon.</param>
		/// <param name="controlCols">Column coordinates of the control polygon.</param>
		/// <param name="knots">Knot vector.</param>
		/// <param name="rows">Row coordinates of the points specified by the user.</param>
		/// <param name="cols">Column coordinates of the points specified by the user.</param>
		/// <param name="tangents">Tangents specified by the user.</param>
		/// <returns>Contour of the modified curve.</returns>
		// Token: 0x06001B5F RID: 7007 RVA: 0x000A8A1C File Offset: 0x000A6C1C
		public HXLDCont DrawNurbsInterpMod(string rotate, string move, string scale, string keepRatio, string edit, int degree, HTuple rowsIn, HTuple colsIn, HTuple tangentsIn, out HTuple controlRows, out HTuple controlCols, out HTuple knots, out HTuple rows, out HTuple cols, out HTuple tangents)
		{
			IntPtr proc = HalconAPI.PreCall(1318);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, rotate);
			HalconAPI.StoreS(proc, 2, move);
			HalconAPI.StoreS(proc, 3, scale);
			HalconAPI.StoreS(proc, 4, keepRatio);
			HalconAPI.StoreS(proc, 5, edit);
			HalconAPI.StoreI(proc, 6, degree);
			HalconAPI.Store(proc, 7, rowsIn);
			HalconAPI.Store(proc, 8, colsIn);
			HalconAPI.Store(proc, 9, tangentsIn);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowsIn);
			HalconAPI.UnpinTuple(colsIn);
			HalconAPI.UnpinTuple(tangentsIn);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out controlRows);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out controlCols);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out knots);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out rows);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out cols);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out tangents);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Interactive drawing of a NURBS curve using interpolation.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="rotate">Enable rotation? Default: "true"</param>
		/// <param name="move">Enable moving? Default: "true"</param>
		/// <param name="scale">Enable scaling? Default: "true"</param>
		/// <param name="keepRatio">Keep ratio while scaling? Default: "true"</param>
		/// <param name="degree">The degree $p$ of the NURBS curve. Reasonable values are 3 to 5. Default: 3</param>
		/// <param name="controlRows">Row coordinates of the control polygon.</param>
		/// <param name="controlCols">Column coordinates of the control polygon.</param>
		/// <param name="knots">Knot vector.</param>
		/// <param name="rows">Row coordinates of the points specified by the user.</param>
		/// <param name="cols">Column coordinates of the points specified by the user.</param>
		/// <param name="tangents">Tangents specified by the user.</param>
		/// <returns>Contour of the curve.</returns>
		// Token: 0x06001B60 RID: 7008 RVA: 0x000A8B40 File Offset: 0x000A6D40
		public HXLDCont DrawNurbsInterp(string rotate, string move, string scale, string keepRatio, int degree, out HTuple controlRows, out HTuple controlCols, out HTuple knots, out HTuple rows, out HTuple cols, out HTuple tangents)
		{
			IntPtr proc = HalconAPI.PreCall(1319);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, rotate);
			HalconAPI.StoreS(proc, 2, move);
			HalconAPI.StoreS(proc, 3, scale);
			HalconAPI.StoreS(proc, 4, keepRatio);
			HalconAPI.StoreI(proc, 5, degree);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out controlRows);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out controlCols);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out knots);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out rows);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out cols);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out tangents);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Interactive modification of a NURBS curve.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="rotate">Enable rotation? Default: "true"</param>
		/// <param name="move">Enable moving? Default: "true"</param>
		/// <param name="scale">Enable scaling? Default: "true"</param>
		/// <param name="keepRatio">Keep ratio while scaling? Default: "true"</param>
		/// <param name="edit">Enable editing? Default: "true"</param>
		/// <param name="degree">The degree $p$ of the NURBS curve. Reasonable values are 3 to 25. Default: 3</param>
		/// <param name="rowsIn">Row coordinates of the input control polygon.</param>
		/// <param name="colsIn">Column coordinates of the input control polygon.</param>
		/// <param name="weightsIn">Input weight vector.</param>
		/// <param name="rows">Row coordinates of the control polygon.</param>
		/// <param name="cols">Columns coordinates of the control polygon.</param>
		/// <param name="weights">Weight vector.</param>
		/// <returns>Contour of the modified curve.</returns>
		// Token: 0x06001B61 RID: 7009 RVA: 0x000A8C2C File Offset: 0x000A6E2C
		public HXLDCont DrawNurbsMod(string rotate, string move, string scale, string keepRatio, string edit, int degree, HTuple rowsIn, HTuple colsIn, HTuple weightsIn, out HTuple rows, out HTuple cols, out HTuple weights)
		{
			IntPtr proc = HalconAPI.PreCall(1320);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, rotate);
			HalconAPI.StoreS(proc, 2, move);
			HalconAPI.StoreS(proc, 3, scale);
			HalconAPI.StoreS(proc, 4, keepRatio);
			HalconAPI.StoreS(proc, 5, edit);
			HalconAPI.StoreI(proc, 6, degree);
			HalconAPI.Store(proc, 7, rowsIn);
			HalconAPI.Store(proc, 8, colsIn);
			HalconAPI.Store(proc, 9, weightsIn);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowsIn);
			HalconAPI.UnpinTuple(colsIn);
			HalconAPI.UnpinTuple(weightsIn);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rows);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out cols);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out weights);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Interactive drawing of a NURBS curve.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="rotate">Enable rotation? Default: "true"</param>
		/// <param name="move">Enable moving? Default: "true"</param>
		/// <param name="scale">Enable scaling? Default: "true"</param>
		/// <param name="keepRatio">Keep ratio while scaling? Default: "true"</param>
		/// <param name="degree">The degree $p$ of the NURBS curve. Reasonable values are 3 to 25. Default: 3</param>
		/// <param name="rows">Row coordinates of the control polygon.</param>
		/// <param name="cols">Columns coordinates of the control polygon.</param>
		/// <param name="weights">Weight vector.</param>
		/// <returns>Contour approximating the NURBS curve.</returns>
		// Token: 0x06001B62 RID: 7010 RVA: 0x000A8D14 File Offset: 0x000A6F14
		public HXLDCont DrawNurbs(string rotate, string move, string scale, string keepRatio, int degree, out HTuple rows, out HTuple cols, out HTuple weights)
		{
			IntPtr proc = HalconAPI.PreCall(1321);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, rotate);
			HalconAPI.StoreS(proc, 2, move);
			HalconAPI.StoreS(proc, 3, scale);
			HalconAPI.StoreS(proc, 4, keepRatio);
			HalconAPI.StoreI(proc, 5, degree);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rows);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out cols);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out weights);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Interactive modification of a contour.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="contIn">Input contour.</param>
		/// <param name="rotate">Enable rotation? Default: "true"</param>
		/// <param name="move">Enable moving? Default: "true"</param>
		/// <param name="scale">Enable scaling? Default: "true"</param>
		/// <param name="keepRatio">Keep ratio while scaling? Default: "true"</param>
		/// <param name="edit">Enable editing? Default: "true"</param>
		/// <returns>Modified contour.</returns>
		// Token: 0x06001B63 RID: 7011 RVA: 0x000A8DC4 File Offset: 0x000A6FC4
		public HXLDCont DrawXldMod(HXLDCont contIn, string rotate, string move, string scale, string keepRatio, string edit)
		{
			IntPtr proc = HalconAPI.PreCall(1322);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, contIn);
			HalconAPI.StoreS(proc, 1, rotate);
			HalconAPI.StoreS(proc, 2, move);
			HalconAPI.StoreS(proc, 3, scale);
			HalconAPI.StoreS(proc, 4, keepRatio);
			HalconAPI.StoreS(proc, 5, edit);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contIn);
			return result;
		}

		/// <summary>
		///   Interactive drawing of a contour.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="rotate">Enable rotation? Default: "true"</param>
		/// <param name="move">Enable moving? Default: "true"</param>
		/// <param name="scale">Enable scaling? Default: "true"</param>
		/// <param name="keepRatio">Keep ratio while scaling? Default: "true"</param>
		/// <returns>Modified contour.</returns>
		// Token: 0x06001B64 RID: 7012 RVA: 0x000A8E48 File Offset: 0x000A7048
		public HXLDCont DrawXld(string rotate, string move, string scale, string keepRatio)
		{
			IntPtr proc = HalconAPI.PreCall(1323);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, rotate);
			HalconAPI.StoreS(proc, 2, move);
			HalconAPI.StoreS(proc, 3, scale);
			HalconAPI.StoreS(proc, 4, keepRatio);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Interactive drawing of any orientated rectangle.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="rowIn">Row index of the center.</param>
		/// <param name="columnIn">Column index of the center.</param>
		/// <param name="phiIn">Orientation of the bigger half axis in radians.</param>
		/// <param name="length1In">Bigger half axis.</param>
		/// <param name="length2In">Smaller half axis.</param>
		/// <param name="row">Row index of the center.</param>
		/// <param name="column">Column index of the center.</param>
		/// <param name="phi">Orientation of the bigger half axis in radians.</param>
		/// <param name="length1">Bigger half axis.</param>
		/// <param name="length2">Smaller half axis.</param>
		// Token: 0x06001B65 RID: 7013 RVA: 0x000A8EB4 File Offset: 0x000A70B4
		public void DrawRectangle2Mod(double rowIn, double columnIn, double phiIn, double length1In, double length2In, out double row, out double column, out double phi, out double length1, out double length2)
		{
			IntPtr proc = HalconAPI.PreCall(1324);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, rowIn);
			HalconAPI.StoreD(proc, 2, columnIn);
			HalconAPI.StoreD(proc, 3, phiIn);
			HalconAPI.StoreD(proc, 4, length1In);
			HalconAPI.StoreD(proc, 5, length2In);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out phi);
			num = HalconAPI.LoadD(proc, 3, num, out length1);
			num = HalconAPI.LoadD(proc, 4, num, out length2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Interactive drawing of any orientated rectangle.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row index of the center.</param>
		/// <param name="column">Column index of the center.</param>
		/// <param name="phi">Orientation of the bigger half axis in radians.</param>
		/// <param name="length1">Bigger half axis.</param>
		/// <param name="length2">Smaller half axis.</param>
		// Token: 0x06001B66 RID: 7014 RVA: 0x000A8F74 File Offset: 0x000A7174
		public void DrawRectangle2(out double row, out double column, out double phi, out double length1, out double length2)
		{
			IntPtr proc = HalconAPI.PreCall(1325);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out phi);
			num = HalconAPI.LoadD(proc, 3, num, out length1);
			num = HalconAPI.LoadD(proc, 4, num, out length2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Draw a rectangle parallel to the coordinate axis.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1In">Row index of the left upper corner.</param>
		/// <param name="column1In">Column index of the left upper corner.</param>
		/// <param name="row2In">Row index of the right lower corner.</param>
		/// <param name="column2In">Column index of the right lower corner.</param>
		/// <param name="row1">Row index of the left upper corner.</param>
		/// <param name="column1">Column index of the left upper corner.</param>
		/// <param name="row2">Row index of the right lower corner.</param>
		/// <param name="column2">Column index of the right lower corner.</param>
		// Token: 0x06001B67 RID: 7015 RVA: 0x000A9004 File Offset: 0x000A7204
		public void DrawRectangle1Mod(double row1In, double column1In, double row2In, double column2In, out double row1, out double column1, out double row2, out double column2)
		{
			IntPtr proc = HalconAPI.PreCall(1326);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, row1In);
			HalconAPI.StoreD(proc, 2, column1In);
			HalconAPI.StoreD(proc, 3, row2In);
			HalconAPI.StoreD(proc, 4, column2In);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row1);
			num = HalconAPI.LoadD(proc, 1, num, out column1);
			num = HalconAPI.LoadD(proc, 2, num, out row2);
			num = HalconAPI.LoadD(proc, 3, num, out column2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Draw a rectangle parallel to the coordinate axis.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1">Row index of the left upper corner.</param>
		/// <param name="column1">Column index of the left upper corner.</param>
		/// <param name="row2">Row index of the right lower corner.</param>
		/// <param name="column2">Column index of the right lower corner.</param>
		// Token: 0x06001B68 RID: 7016 RVA: 0x000A90A8 File Offset: 0x000A72A8
		public void DrawRectangle1(out double row1, out double column1, out double row2, out double column2)
		{
			IntPtr proc = HalconAPI.PreCall(1327);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row1);
			num = HalconAPI.LoadD(proc, 1, num, out column1);
			num = HalconAPI.LoadD(proc, 2, num, out row2);
			num = HalconAPI.LoadD(proc, 3, num, out column2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Draw a point.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="rowIn">Row index of the point.</param>
		/// <param name="columnIn">Column index of the point.</param>
		/// <param name="row">Row index of the point.</param>
		/// <param name="column">Column index of the point.</param>
		// Token: 0x06001B69 RID: 7017 RVA: 0x000A9128 File Offset: 0x000A7328
		public void DrawPointMod(double rowIn, double columnIn, out double row, out double column)
		{
			IntPtr proc = HalconAPI.PreCall(1328);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, rowIn);
			HalconAPI.StoreD(proc, 2, columnIn);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Draw a point.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row index of the point.</param>
		/// <param name="column">Column index of the point.</param>
		// Token: 0x06001B6A RID: 7018 RVA: 0x000A9194 File Offset: 0x000A7394
		public void DrawPoint(out double row, out double column)
		{
			IntPtr proc = HalconAPI.PreCall(1329);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Draw a line.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1In">Row index of the first point of the line.</param>
		/// <param name="column1In">Column index of the first point of the line.</param>
		/// <param name="row2In">Row index of the second point of the line.</param>
		/// <param name="column2In">Column index of the second point of the line.</param>
		/// <param name="row1">Row index of the first point of the line.</param>
		/// <param name="column1">Column index of the first point of the line.</param>
		/// <param name="row2">Row index of the second point of the line.</param>
		/// <param name="column2">Column index of the second point of the line.</param>
		// Token: 0x06001B6B RID: 7019 RVA: 0x000A91EC File Offset: 0x000A73EC
		public void DrawLineMod(double row1In, double column1In, double row2In, double column2In, out double row1, out double column1, out double row2, out double column2)
		{
			IntPtr proc = HalconAPI.PreCall(1330);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, row1In);
			HalconAPI.StoreD(proc, 2, column1In);
			HalconAPI.StoreD(proc, 3, row2In);
			HalconAPI.StoreD(proc, 4, column2In);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row1);
			num = HalconAPI.LoadD(proc, 1, num, out column1);
			num = HalconAPI.LoadD(proc, 2, num, out row2);
			num = HalconAPI.LoadD(proc, 3, num, out column2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Draw a line.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row1">Row index of the first point of the line.</param>
		/// <param name="column1">Column index of the first point of the line.</param>
		/// <param name="row2">Row index of the second point of the line.</param>
		/// <param name="column2">Column index of the second point of the line.</param>
		// Token: 0x06001B6C RID: 7020 RVA: 0x000A9290 File Offset: 0x000A7490
		public void DrawLine(out double row1, out double column1, out double row2, out double column2)
		{
			IntPtr proc = HalconAPI.PreCall(1331);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row1);
			num = HalconAPI.LoadD(proc, 1, num, out column1);
			num = HalconAPI.LoadD(proc, 2, num, out row2);
			num = HalconAPI.LoadD(proc, 3, num, out column2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Interactive drawing of an ellipse.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="rowIn">Row index of the center.</param>
		/// <param name="columnIn">Column index of the center.</param>
		/// <param name="phiIn">Orientation of the bigger half axis in radians.</param>
		/// <param name="radius1In">Bigger half axis.</param>
		/// <param name="radius2In">Smaller half axis.</param>
		/// <param name="row">Row index of the center.</param>
		/// <param name="column">Column index of the center.</param>
		/// <param name="phi">Orientation of the first half axis in radians.</param>
		/// <param name="radius1">First half axis.</param>
		/// <param name="radius2">Second half axis.</param>
		// Token: 0x06001B6D RID: 7021 RVA: 0x000A9310 File Offset: 0x000A7510
		public void DrawEllipseMod(double rowIn, double columnIn, double phiIn, double radius1In, double radius2In, out double row, out double column, out double phi, out double radius1, out double radius2)
		{
			IntPtr proc = HalconAPI.PreCall(1332);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, rowIn);
			HalconAPI.StoreD(proc, 2, columnIn);
			HalconAPI.StoreD(proc, 3, phiIn);
			HalconAPI.StoreD(proc, 4, radius1In);
			HalconAPI.StoreD(proc, 5, radius2In);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out phi);
			num = HalconAPI.LoadD(proc, 3, num, out radius1);
			num = HalconAPI.LoadD(proc, 4, num, out radius2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Interactive drawing of an ellipse.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Row index of the center.</param>
		/// <param name="column">Column index of the center.</param>
		/// <param name="phi">Orientation of the first half axis in radians.</param>
		/// <param name="radius1">First half axis.</param>
		/// <param name="radius2">Second half axis.</param>
		// Token: 0x06001B6E RID: 7022 RVA: 0x000A93D0 File Offset: 0x000A75D0
		public void DrawEllipse(out double row, out double column, out double phi, out double radius1, out double radius2)
		{
			IntPtr proc = HalconAPI.PreCall(1333);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out phi);
			num = HalconAPI.LoadD(proc, 3, num, out radius1);
			num = HalconAPI.LoadD(proc, 4, num, out radius2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Interactive drawing of a circle.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="rowIn">Row index of the center.</param>
		/// <param name="columnIn">Column index of the center.</param>
		/// <param name="radiusIn">Radius of the circle.</param>
		/// <param name="row">Row index of the center.</param>
		/// <param name="column">Column index of the center.</param>
		/// <param name="radius">Circle's radius.</param>
		// Token: 0x06001B6F RID: 7023 RVA: 0x000A9460 File Offset: 0x000A7660
		public void DrawCircleMod(double rowIn, double columnIn, double radiusIn, out double row, out double column, out double radius)
		{
			IntPtr proc = HalconAPI.PreCall(1334);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, rowIn);
			HalconAPI.StoreD(proc, 2, columnIn);
			HalconAPI.StoreD(proc, 3, radiusIn);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out radius);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Interactive drawing of a circle.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="row">Barycenter's row index.</param>
		/// <param name="column">Barycenter's column index.</param>
		/// <param name="radius">Circle's radius.</param>
		// Token: 0x06001B70 RID: 7024 RVA: 0x000A94E8 File Offset: 0x000A76E8
		public void DrawCircle(out double row, out double column, out double radius)
		{
			IntPtr proc = HalconAPI.PreCall(1335);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out radius);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Interactive drawing of a closed region.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Interactive created region.</returns>
		// Token: 0x06001B71 RID: 7025 RVA: 0x000A9554 File Offset: 0x000A7754
		public HRegion DrawRegion()
		{
			IntPtr proc = HalconAPI.PreCall(1336);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Interactive drawing of a polygon row.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Region, which encompasses all painted points.</returns>
		// Token: 0x06001B72 RID: 7026 RVA: 0x000A959C File Offset: 0x000A779C
		public HRegion DrawPolygon()
		{
			IntPtr proc = HalconAPI.PreCall(1337);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Project and visualize the 3D model of the calibration plate in the image.
		///   Instance represents: Window in which the calibration plate should be visualized.
		/// </summary>
		/// <param name="calPlateDescr">File name of the calibration plate description. Default: "calplate_320.cpd"</param>
		/// <param name="cameraParam">Internal camera parameters.</param>
		/// <param name="calPlatePose">External camera parameters (3D pose of the calibration plate in camera coordinates).</param>
		/// <param name="scaleFac">Scaling factor for the visualization. Default: 1.0</param>
		// Token: 0x06001B73 RID: 7027 RVA: 0x000A95E4 File Offset: 0x000A77E4
		public void DispCaltab(string calPlateDescr, HCamPar cameraParam, HPose calPlatePose, double scaleFac)
		{
			IntPtr proc = HalconAPI.PreCall(1945);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, calPlateDescr);
			HalconAPI.Store(proc, 2, cameraParam);
			HalconAPI.Store(proc, 3, calPlatePose);
			HalconAPI.StoreD(proc, 4, scaleFac);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(cameraParam);
			HalconAPI.UnpinTuple(calPlatePose);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Convert image coordinates to window coordinates
		///   Instance represents: Window handle
		/// </summary>
		/// <param name="rowImage">Row in image coordinates.</param>
		/// <param name="columnImage">Column in image coordinates.</param>
		/// <param name="rowWindow">Row (Y) in window coordinates.</param>
		/// <param name="columnWindow">Column (X) in window coordinates.</param>
		// Token: 0x06001B74 RID: 7028 RVA: 0x000A965C File Offset: 0x000A785C
		public void ConvertCoordinatesImageToWindow(HTuple rowImage, HTuple columnImage, out HTuple rowWindow, out HTuple columnWindow)
		{
			IntPtr proc = HalconAPI.PreCall(2049);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, rowImage);
			HalconAPI.Store(proc, 2, columnImage);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowImage);
			HalconAPI.UnpinTuple(columnImage);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowWindow);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out columnWindow);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Convert image coordinates to window coordinates
		///   Instance represents: Window handle
		/// </summary>
		/// <param name="rowImage">Row in image coordinates.</param>
		/// <param name="columnImage">Column in image coordinates.</param>
		/// <param name="rowWindow">Row (Y) in window coordinates.</param>
		/// <param name="columnWindow">Column (X) in window coordinates.</param>
		// Token: 0x06001B75 RID: 7029 RVA: 0x000A96D4 File Offset: 0x000A78D4
		public void ConvertCoordinatesImageToWindow(double rowImage, double columnImage, out double rowWindow, out double columnWindow)
		{
			IntPtr proc = HalconAPI.PreCall(2049);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, rowImage);
			HalconAPI.StoreD(proc, 2, columnImage);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out rowWindow);
			num = HalconAPI.LoadD(proc, 1, num, out columnWindow);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Convert window coordinates to image coordinates
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="rowWindow">Row (Y) in window coordinates.</param>
		/// <param name="columnWindow">Column (X) in window coordinates.</param>
		/// <param name="rowImage">Row in image coordinates.</param>
		/// <param name="columnImage">Column in image coordinates.</param>
		// Token: 0x06001B76 RID: 7030 RVA: 0x000A9740 File Offset: 0x000A7940
		public void ConvertCoordinatesWindowToImage(HTuple rowWindow, HTuple columnWindow, out HTuple rowImage, out HTuple columnImage)
		{
			IntPtr proc = HalconAPI.PreCall(2050);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, rowWindow);
			HalconAPI.Store(proc, 2, columnWindow);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowWindow);
			HalconAPI.UnpinTuple(columnWindow);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowImage);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out columnImage);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Convert window coordinates to image coordinates
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="rowWindow">Row (Y) in window coordinates.</param>
		/// <param name="columnWindow">Column (X) in window coordinates.</param>
		/// <param name="rowImage">Row in image coordinates.</param>
		/// <param name="columnImage">Column in image coordinates.</param>
		// Token: 0x06001B77 RID: 7031 RVA: 0x000A97B8 File Offset: 0x000A79B8
		public void ConvertCoordinatesWindowToImage(double rowWindow, double columnWindow, out double rowImage, out double columnImage)
		{
			IntPtr proc = HalconAPI.PreCall(2050);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, rowWindow);
			HalconAPI.StoreD(proc, 2, columnWindow);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out rowImage);
			num = HalconAPI.LoadD(proc, 1, num, out columnImage);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Display text in a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="stringVal">A tuple of strings containing the text message to be displayed. Each value of the tuple will be displayed in a single line. Default: "hello"</param>
		/// <param name="coordSystem">If set to 'window', the text position is given with respect to the window coordinate system. If set to 'image', image coordinates are used (this may be useful in zoomed images). Default: "window"</param>
		/// <param name="row">The vertical text alignment or the row coordinate of the desired text position. Default: 12</param>
		/// <param name="column">The horizontal text alignment or the column coordinate of  the desired text position. Default: 12</param>
		/// <param name="color">A tuple of strings defining the colors of the texts. Default: "black"</param>
		/// <param name="genParamName">Generic parameter names. Default: []</param>
		/// <param name="genParamValue">Generic parameter values. Default: []</param>
		// Token: 0x06001B78 RID: 7032 RVA: 0x000A9824 File Offset: 0x000A7A24
		public void DispText(HTuple stringVal, string coordSystem, HTuple row, HTuple column, HTuple color, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(2055);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, stringVal);
			HalconAPI.StoreS(proc, 2, coordSystem);
			HalconAPI.Store(proc, 3, row);
			HalconAPI.Store(proc, 4, column);
			HalconAPI.Store(proc, 5, color);
			HalconAPI.Store(proc, 6, genParamName);
			HalconAPI.Store(proc, 7, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(stringVal);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(color);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Display text in a window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="stringVal">A tuple of strings containing the text message to be displayed. Each value of the tuple will be displayed in a single line. Default: "hello"</param>
		/// <param name="coordSystem">If set to 'window', the text position is given with respect to the window coordinate system. If set to 'image', image coordinates are used (this may be useful in zoomed images). Default: "window"</param>
		/// <param name="row">The vertical text alignment or the row coordinate of the desired text position. Default: 12</param>
		/// <param name="column">The horizontal text alignment or the column coordinate of  the desired text position. Default: 12</param>
		/// <param name="color">A tuple of strings defining the colors of the texts. Default: "black"</param>
		/// <param name="genParamName">Generic parameter names. Default: []</param>
		/// <param name="genParamValue">Generic parameter values. Default: []</param>
		// Token: 0x06001B79 RID: 7033 RVA: 0x000A98BC File Offset: 0x000A7ABC
		public void DispText(string stringVal, string coordSystem, int row, int column, string color, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(2055);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, stringVal);
			HalconAPI.StoreS(proc, 2, coordSystem);
			HalconAPI.StoreI(proc, 3, row);
			HalconAPI.StoreI(proc, 4, column);
			HalconAPI.StoreS(proc, 5, color);
			HalconAPI.Store(proc, 6, genParamName);
			HalconAPI.Store(proc, 7, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Flush the contents of a window.
		///   Instance represents: Window handle.
		/// </summary>
		// Token: 0x06001B7A RID: 7034 RVA: 0x000A993C File Offset: 0x000A7B3C
		public void FlushBuffer()
		{
			IntPtr proc = HalconAPI.PreCall(2070);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Get the current color in RGBA-coding.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="red">The current color's red value.</param>
		/// <param name="green">The current color's green value.</param>
		/// <param name="blue">The current color's blue value.</param>
		/// <param name="alpha">The current color's alpha value.</param>
		// Token: 0x06001B7B RID: 7035 RVA: 0x000A9970 File Offset: 0x000A7B70
		public void GetRgba(out HTuple red, out HTuple green, out HTuple blue, out HTuple alpha)
		{
			IntPtr proc = HalconAPI.PreCall(2073);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out red);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out green);
			num = HTuple.LoadNew(proc, 2, HTupleType.INTEGER, num, out blue);
			num = HTuple.LoadNew(proc, 3, HTupleType.INTEGER, num, out alpha);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Send an event to a buffer window signaling a mouse double click event.
		///   Instance represents: Window handle of the buffer window.
		/// </summary>
		/// <param name="row">Row coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="column">Column coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="button">Mouse button(s) pressed.</param>
		/// <returns>'true', if HALCON processed the event.</returns>
		// Token: 0x06001B7C RID: 7036 RVA: 0x000A99F4 File Offset: 0x000A7BF4
		public string SendMouseDoubleClickEvent(HTuple row, HTuple column, int button)
		{
			IntPtr proc = HalconAPI.PreCall(2088);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			HalconAPI.StoreI(proc, 3, button);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Send an event to a buffer window signaling a mouse double click event.
		///   Instance represents: Window handle of the buffer window.
		/// </summary>
		/// <param name="row">Row coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="column">Column coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="button">Mouse button(s) pressed.</param>
		/// <returns>'true', if HALCON processed the event.</returns>
		// Token: 0x06001B7D RID: 7037 RVA: 0x000A9A60 File Offset: 0x000A7C60
		public string SendMouseDoubleClickEvent(int row, int column, int button)
		{
			IntPtr proc = HalconAPI.PreCall(2088);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.StoreI(proc, 3, button);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Send an event to a window buffer signaling a mouse down event.
		///   Instance represents: Window handle of the buffer window.
		/// </summary>
		/// <param name="row">Row coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="column">Column coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="button">Mouse button(s) pressed.</param>
		/// <returns>'true', if HALCON processed the event.</returns>
		// Token: 0x06001B7E RID: 7038 RVA: 0x000A9AC0 File Offset: 0x000A7CC0
		public string SendMouseDownEvent(HTuple row, HTuple column, int button)
		{
			IntPtr proc = HalconAPI.PreCall(2089);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			HalconAPI.StoreI(proc, 3, button);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Send an event to a window buffer signaling a mouse down event.
		///   Instance represents: Window handle of the buffer window.
		/// </summary>
		/// <param name="row">Row coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="column">Column coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="button">Mouse button(s) pressed.</param>
		/// <returns>'true', if HALCON processed the event.</returns>
		// Token: 0x06001B7F RID: 7039 RVA: 0x000A9B2C File Offset: 0x000A7D2C
		public string SendMouseDownEvent(int row, int column, int button)
		{
			IntPtr proc = HalconAPI.PreCall(2089);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.StoreI(proc, 3, button);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Send an event to a buffer window signaling a mouse drag event.
		///   Instance represents: Window handle of the buffer window.
		/// </summary>
		/// <param name="row">Row coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="column">Column coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="button">Mouse button(s) pressed.</param>
		/// <returns>'true', if HALCON processed the event.</returns>
		// Token: 0x06001B80 RID: 7040 RVA: 0x000A9B8C File Offset: 0x000A7D8C
		public string SendMouseDragEvent(HTuple row, HTuple column, int button)
		{
			IntPtr proc = HalconAPI.PreCall(2090);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			HalconAPI.StoreI(proc, 3, button);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Send an event to a buffer window signaling a mouse drag event.
		///   Instance represents: Window handle of the buffer window.
		/// </summary>
		/// <param name="row">Row coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="column">Column coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="button">Mouse button(s) pressed.</param>
		/// <returns>'true', if HALCON processed the event.</returns>
		// Token: 0x06001B81 RID: 7041 RVA: 0x000A9BF8 File Offset: 0x000A7DF8
		public string SendMouseDragEvent(int row, int column, int button)
		{
			IntPtr proc = HalconAPI.PreCall(2090);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.StoreI(proc, 3, button);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Send an event to a buffer window signaling a mouse up event.
		///   Instance represents: Window handle of the buffer window.
		/// </summary>
		/// <param name="row">Row coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="column">Column coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="button">Mouse button(s) pressed.</param>
		/// <returns>'true', if HALCON processed the event.</returns>
		// Token: 0x06001B82 RID: 7042 RVA: 0x000A9C58 File Offset: 0x000A7E58
		public string SendMouseUpEvent(HTuple row, HTuple column, int button)
		{
			IntPtr proc = HalconAPI.PreCall(2091);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, row);
			HalconAPI.Store(proc, 2, column);
			HalconAPI.StoreI(proc, 3, button);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Send an event to a buffer window signaling a mouse up event.
		///   Instance represents: Window handle of the buffer window.
		/// </summary>
		/// <param name="row">Row coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="column">Column coordinate of the mouse cursor in the image coordinate system.</param>
		/// <param name="button">Mouse button(s) pressed.</param>
		/// <returns>'true', if HALCON processed the event.</returns>
		// Token: 0x06001B83 RID: 7043 RVA: 0x000A9CC4 File Offset: 0x000A7EC4
		public string SendMouseUpEvent(int row, int column, int button)
		{
			IntPtr proc = HalconAPI.PreCall(2091);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, row);
			HalconAPI.StoreI(proc, 2, column);
			HalconAPI.StoreI(proc, 3, button);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Sets the callback for content updates in buffer window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="callbackFunction">Callback for content updates.</param>
		/// <param name="callbackContext">Parameter to CallbackFunction.</param>
		// Token: 0x06001B84 RID: 7044 RVA: 0x000A9D24 File Offset: 0x000A7F24
		public void SetContentUpdateCallback(IntPtr callbackFunction, HTuple callbackContext)
		{
			IntPtr proc = HalconAPI.PreCall(2095);
			base.Store(proc, 0);
			HalconAPI.StoreIP(proc, 1, callbackFunction);
			HalconAPI.Store(proc, 2, callbackContext);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(callbackContext);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Sets the callback for content updates in buffer window.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="callbackFunction">Callback for content updates.</param>
		/// <param name="callbackContext">Parameter to CallbackFunction.</param>
		// Token: 0x06001B85 RID: 7045 RVA: 0x000A9D70 File Offset: 0x000A7F70
		public void SetContentUpdateCallback(IntPtr callbackFunction, IntPtr callbackContext)
		{
			IntPtr proc = HalconAPI.PreCall(2095);
			base.Store(proc, 0);
			HalconAPI.StoreIP(proc, 1, callbackFunction);
			HalconAPI.StoreIP(proc, 2, callbackContext);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set the color definition via RGBA values.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="red">Red component of the color. Default: 255</param>
		/// <param name="green">Green component of the color. Default: 0</param>
		/// <param name="blue">Blue component of the color. Default: 0</param>
		/// <param name="alpha">Alpha component of the color. Default: 255</param>
		// Token: 0x06001B86 RID: 7046 RVA: 0x000A9DB4 File Offset: 0x000A7FB4
		public void SetRgba(HTuple red, HTuple green, HTuple blue, HTuple alpha)
		{
			IntPtr proc = HalconAPI.PreCall(2096);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, red);
			HalconAPI.Store(proc, 2, green);
			HalconAPI.Store(proc, 3, blue);
			HalconAPI.Store(proc, 4, alpha);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(red);
			HalconAPI.UnpinTuple(green);
			HalconAPI.UnpinTuple(blue);
			HalconAPI.UnpinTuple(alpha);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set the color definition via RGBA values.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="red">Red component of the color. Default: 255</param>
		/// <param name="green">Green component of the color. Default: 0</param>
		/// <param name="blue">Blue component of the color. Default: 0</param>
		/// <param name="alpha">Alpha component of the color. Default: 255</param>
		// Token: 0x06001B87 RID: 7047 RVA: 0x000A9E24 File Offset: 0x000A8024
		public void SetRgba(int red, int green, int blue, int alpha)
		{
			IntPtr proc = HalconAPI.PreCall(2096);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, red);
			HalconAPI.StoreI(proc, 2, green);
			HalconAPI.StoreI(proc, 3, blue);
			HalconAPI.StoreI(proc, 4, alpha);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Get the current contour display fill style.
		///   Instance represents: Window handle.
		/// </summary>
		/// <returns>Current contour fill style.</returns>
		// Token: 0x06001B88 RID: 7048 RVA: 0x000A9E7C File Offset: 0x000A807C
		public string GetContourStyle()
		{
			IntPtr proc = HalconAPI.PreCall(2177);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Define the contour display fill style.
		///   Instance represents: Window handle.
		/// </summary>
		/// <param name="style">Fill style of contour displays. Default: "stroke"</param>
		// Token: 0x06001B89 RID: 7049 RVA: 0x000A9EC4 File Offset: 0x000A80C4
		public void SetContourStyle(string style)
		{
			IntPtr proc = HalconAPI.PreCall(2179);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, style);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		// Token: 0x04001138 RID: 4408
		private HWindow.ContentUpdateCallback _callback;

		// Token: 0x020000B2 RID: 178
		// (Invoke) Token: 0x0600205B RID: 8283
		internal delegate int ContentUpdateCallback(IntPtr context);
	}
}
